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,
-    ScrollArea, SidePanel, Stroke, TopBottomPanel, Ui, ViewportCommand,
+    Align, CentralPanel, CollapsingHeader, Color32, Context, CornerRadius, Frame, Layout,
+    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 ---
@@ -262,7 +280,6 @@ impl eframe::App for P2PClientApp {
                     if let Some(addr) = &self.active_peer {
                         if let Some(roottree) = self.loaded_fs.get(addr) {
                             if let Some(root) = roottree.data.get(&hash) {
-                                self.current_downloading_file_map.root = hash;
                                 self.root_downloading_file = name;
                                 let _ = self
                                     .current_downloading_file_map
@@ -292,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);
                         }
@@ -300,12 +318,18 @@ impl eframe::App for P2PClientApp {
                         }
                         _ => {}
                     }
-                    println!("remaining chunks size: {}", self.remaining_chunks.len());
+
+                    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).create(true).open(
-                            "./Download/".to_string()
-                                + &remove_null_bytes(&self.root_downloading_file.clone()),
-                        );
+                        /*let file = OpenOptions::new()
+                            .append(true)
+                            .create(true)
+                            .open(self.root_downloading_file.clone());
 
                         if let Some(current) = self
                             .current_downloading_file_map
@@ -324,10 +348,10 @@ impl eframe::App for P2PClientApp {
                                     eprintln!("error creaation file: {}", e);
                                 }
                             }
-                        } else {
-                            eprintln!("error root absent");
-                        }
-                        println!("bigfile téléchargé {}", self.root_downloading_file);
+                        }*/
+                        self.current_total_chunks = None;
+                        self.current_received_chunks = 0;
+                        println!("bigfile téléchargé");
                     }
                 }
                 NetworkEvent::Success(msg, peer_username) => {
@@ -407,26 +431,35 @@ impl eframe::App for P2PClientApp {
         TopBottomPanel::bottom("bottom_panel").show(ctx, |ui| {
             ui.horizontal(|ui| {
                 match self.server_status {
-                    ServerStatus::Loading => {
-                        ui.spinner();
+                    ServerStatus::Loading => 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));
             });
         });
 
@@ -457,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.");
@@ -509,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 {
@@ -520,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.)
@@ -535,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(),
@@ -678,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.");
@@ -734,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
@@ -751,7 +799,7 @@ impl P2PClientApp {
     }
 
     fn draw_file_node(
-        &self,
+        &mut self,
         ui: &mut Ui,
         to_draw: NodeHash,
         tree: &MerkleTree,

client-network/src/data.rs

@@ -473,15 +473,8 @@ pub fn big_or_chunk_to_file(tree: &MerkleTree, node: &MerkleNode, file: &mut Fil
             }
         }
         MerkleNode::Chunk(chunk) => {
-            if !chunk.data.is_empty() {
-                // Enlève le premier élément
-                let mut data = chunk.data.clone(); // Clone pour éviter de modifier l'original
-                data.remove(0); // Enlève le premier élément
-                println!("wrote data {:?}", data);
-                let _ = file.write(&data);
-            } else {
-                println!("chunk.data is empty, nothing to write");
-            }
+            println!("wrote data");
+            let _ = file.write_all(&chunk.data);
         }
         _ => {
             println!("invalid type of file");

client-network/src/datum_parsing.rs

@@ -11,27 +11,9 @@ pub fn parse_received_datum(
     datum_length: usize,
 ) -> Option<([u8; 32], MerkleNode)> {
     let hash_name: [u8; 32] = recevied_datum[..32].try_into().expect("error");
-    let value = &recevied_datum[32..datum_length];
+    let value = &recevied_datum[32..recevied_datum.len()];
     let value_slice = value.to_vec();
     println!("valueslice: {:?}, {}", value_slice, value_slice.len());
-
-    println!(
-        "((value_slice.len() - 1) / 32) {} ",
-        ((value_slice.len() - 1) / 32)
-    );
-    // Créer une instance de Sha256
-    let mut hasher = Sha256::new();
-
-    // Alimenter le hasher avec les données
-    hasher.update(value_slice.clone());
-
-    // Obtention du résultat
-    let result = hasher.finalize();
-    if result.to_vec() != hash_name.to_vec() {
-        println!("{:?},{:?}", result.to_vec(), hash_name.to_vec());
-        None
-    } else {
-        println!("hashes equals!");
     let datum_type = value_slice[0];
     match datum_type {
         CHUNK => Some((
@@ -109,5 +91,4 @@ pub fn parse_received_datum(
         }
         _ => None,
     }
-    }
 }

client-network/src/lib.rs

@@ -73,7 +73,7 @@ impl P2PSharedData {
 
         let mut threads = Vec::new();
 
-        let senders = MultipleSenders::new(5, &shared_socket, cmd_tx, &mut threads);
+        let senders = MultipleSenders::new(1, &shared_socket, cmd_tx, &mut threads);
         let shared_senders = Arc::new(senders);
         let server_name = Arc::new(Mutex::new("".to_string()));
         let server_address = Arc::new(Mutex::new("".to_string()));
@@ -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 =
-                                perform_handshake(&sd, username, ip, event_tx.clone(), true).await;
+                            sd.set_servername(username.to_owned());
+                            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()));
@@ -370,11 +370,14 @@ pub fn parse_message(
                             // envoyer la root request
                             let _ = &guard.remove_entry(&id);
                             println!("message {} retiré de la liste", id);
-                            let new_id = generate_id();
-                            let rootrequest =
-                                construct_message(ROOTREQUEST, Vec::new(), new_id, crypto_pair);
-                            let _ = &guard.insert(new_id, EventType::RootRequest);
-                            println!("root requesst sent");
+
+                            let rootrequest = construct_message(
+                                ROOTREQUEST,
+                                Vec::new(),
+                                generate_id(),
+                                crypto_pair,
+                            );
+                            //&guard.insert(, v)
                             return rootrequest;
                         }
                         EventType::Hello => {
@@ -389,7 +392,6 @@ pub fn parse_message(
         }
         ROOTREPLY => {
             // recuperer le pseudo du peers ayant repondu
-            println!("root reply received");
             let peers_exist = handhsake_history.get_peer_info_ip(ip.to_string());
             match peers_exist {
                 Some(peerinfo) => {
@@ -427,9 +429,7 @@ pub fn parse_message(
                                     constructed_message = datumreqest;
                                     guard.insert(new_id, EventType::DatumRequest);
                                 }
-                                _ => {
-                                    println!("event not prensent");
-                                }
+                                _ => {}
                             }
                         }
                         None => {}
@@ -468,6 +468,7 @@ pub fn parse_message(
                         }
                     }
                     EventType::DatumRequestBig => {
+                        let _ = &guard.remove_entry(&id);
                         println!("message {} retiré de la liste", id);
                         let received_length = u16::from_be_bytes(
                             received_message[TYPE..LENGTH]
@@ -480,7 +481,6 @@ pub fn parse_message(
                             parse_received_datum(received_datum.to_vec(), received_length as usize);
                         match parsed_node {
                             Some(tuple) => {
-                                let _ = &guard.remove_entry(&id);
                                 let _ = cmd_tx.send(NetworkEvent::DataReceived(
                                     tuple.0,
                                     tuple.1,
@@ -488,9 +488,7 @@ pub fn parse_message(
                                 ));
                                 println!("datareceived event sent");
                             }
-                            None => {
-                                println!("message corrompu, nouvelle tentative");
-                            }
+                            None => {}
                         }
                     }
                     _ => {}

client-network/src/messages_channels.rs

@@ -234,8 +234,7 @@ pub fn start_retry_thread(
                             );
                             let base: u64 = 2;
 
-                            // let backoff = base.saturating_pow(attempt as u32); // 2^1 == 2 seconds
-                            let backoff = 1;
+                            let backoff = base.saturating_pow(attempt as u32); // 2^1 == 2 seconds
                             let newretry = RetryMessage {
                                 next_try: SystemTime::now()
                                     .duration_since(UNIX_EPOCH)
@@ -273,7 +272,7 @@ pub fn start_receving_thread(
     let messages_received_clone = shared_data.messages_received();
     let servername_clone = shared_data.servername();
     let thread = thread::spawn(move || {
-        let mut buf = [0u8; 1500];
+        let mut buf = [0u8; 1024];
         loop {
             match sock_clone.recv_from(&mut buf) {
                 Ok((amt, src)) => {

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,27 +56,50 @@ 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 {
-        Some(sockaddr_bytes) => {
-            sd.set_servername(username);
-            // first: &SocketAddr
+
+    let address = {
+        if is_server_handshake.0 {
+            is_server_handshake.1
+        } 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 {
-                println!("hello the nroot");
         sd.add_message(id, EventType::HelloThenRootRequest);
     }
 
@@ -83,19 +107,19 @@ pub async fn perform_handshake(
         Some(handshake_message) => {
             senders.send_dispatch(
                 handshake_message,
-                        sockaddr_bytes.to_string(),
-                        is_server_handshake,
+                address,
+                is_server_handshake.0,
                 sd.messages_list(),
             );
         }
         None => {}
     }
-        }
-        None => {
-            let err_msg = format!("failed to retreive socket address:").to_string();
-            let res = event_tx.send(NetworkEvent::Error(err_msg, "".to_owned()));
-        }
-    }
+
+    //let server_addr_query = get_socket_address(username.clone(), ip.clone(), Some(sd)).await;
+    //match server_addr_query {
+    //    Ok(sockaddr_bytes) => {}
+    //    Err(err_msg) => {}
+    //}
 
     /*let mut list = messages_list.lock().expect("Failed to lock messages_list");
     match list.get(&id) {
@@ -113,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)]