bob/p2p
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

tidy

Browse Source
This commit is contained in:
Tiago Batista Cardoso
2026-01-25 02:16:22 +01:00
parent 929c386b09
commit 54cd6ebc41
2 changed files with 30 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

206
client-gui/src/gui_app.rs
View File

@@ -1,18 +1,16 @@
use client_network::{ use client_network::{
ChunkNode, MerkleNode, MerkleTree, NetworkCommand, NetworkEvent, NodeHash, ChunkNode, MerkleNode, MerkleTree, NetworkCommand, NetworkEvent, NodeHash,
big_or_chunk_to_file, filename_to_string, generate_base_tree, node_hash_to_hex_string, big_or_chunk_to_file, generate_base_tree, node_hash_to_hex_string, remove_null_bytes,
node_to_file, remove_null_bytes,
}; };
use crossbeam_channel::{Receiver, Sender}; use crossbeam_channel::{Receiver, Sender};
use egui::{ use egui::{
Align, CentralPanel, CollapsingHeader, Color32, Context, CornerRadius, Frame, Id, Layout, Align, CentralPanel, CollapsingHeader, Color32, Context, CornerRadius, Frame, Id, Layout,
ProgressBar, Response, ScrollArea, SidePanel, Stroke, TopBottomPanel, Ui, Vec2, ProgressBar, Response, ScrollArea, SidePanel, Stroke, TopBottomPanel, Ui, ViewportCommand,
ViewportCommand,
}; };
use std::collections::HashMap;
use std::collections::HashSet; use std::collections::HashSet;
use std::{collections::HashMap, fmt::format, io::Seek};
use std::fs::{File, OpenOptions, create_dir}; use std::fs::{OpenOptions, create_dir};
enum ServerStatus { enum ServerStatus {
Loading, Loading,
@@ -21,24 +19,19 @@ enum ServerStatus {
ConnectedHandshake, ConnectedHandshake,
} }
// --- Main Application Struct ---
pub struct P2PClientApp { pub struct P2PClientApp {
remaining: std::time::Duration, // temps restant remaining: std::time::Duration, // temps restant
last_update: std::time::Instant, // pour calculer delta last_update: std::time::Instant, // pour calculer delta
timer_started: bool, timer_started: bool,
// Communication channels
network_cmd_tx: Sender<NetworkCommand>, network_cmd_tx: Sender<NetworkCommand>,
network_event_rx: Receiver<NetworkEvent>, network_event_rx: Receiver<NetworkEvent>,
// GUI State
status_message: String,
known_peers: Vec<(String, bool)>, known_peers: Vec<(String, bool)>,
loading_peers: Vec<String>, loading_peers: Vec<String>,
connect_address_input: String, connect_address_input: String,
connected_address: String, connected_address: String,
connect_name_input: String, connect_name_input: String,
// Key: Parent Directory Hash (String), Value: List of children FileNode
loaded_fs: HashMap<String, MerkleTree>, loaded_fs: HashMap<String, MerkleTree>,
shared_tree: MerkleTree, shared_tree: MerkleTree,
@@ -67,12 +60,8 @@ pub struct P2PClientApp {
impl P2PClientApp { impl P2PClientApp {
pub fn new(cmd_tx: Sender<NetworkCommand>, event_rx: Receiver<NetworkEvent>) -> Self { pub fn new(cmd_tx: Sender<NetworkCommand>, event_rx: Receiver<NetworkEvent>) -> Self {
//let (root_hash, tree_content) = MerkleNode::generate_base_tree(); let loaded_fs = HashMap::new();
let current_downloading_file_map = MerkleTree::new(HashMap::new(), [0; 32]);
let mut loaded_fs = HashMap::new();
let mut current_downloading_file_map = MerkleTree::new(HashMap::new(), [0; 32]);
//let tree = MerkleTree::new(tree_content, root_hash);
//loaded_fs.insert("bob".to_string(), tree);
Self { Self {
remaining: std::time::Duration::from_secs(0), remaining: std::time::Duration::from_secs(0),
@@ -80,7 +69,6 @@ impl P2PClientApp {
last_update: std::time::Instant::now(), last_update: std::time::Instant::now(),
network_cmd_tx: cmd_tx, network_cmd_tx: cmd_tx,
network_event_rx: event_rx, network_event_rx: event_rx,
status_message: "Client Initialized. Awaiting network status...".to_string(),
known_peers: Vec::new(), known_peers: Vec::new(),
loading_peers: Vec::new(), loading_peers: Vec::new(),
connect_address_input: "https://jch.irif.fr:8443".to_string(), connect_address_input: "https://jch.irif.fr:8443".to_string(),
@@ -114,18 +102,8 @@ impl P2PClientApp {
pub fn clear_success(&mut self) { pub fn clear_success(&mut self) {
self.success_message = None; 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 ---
impl eframe::App for P2PClientApp { impl eframe::App for P2PClientApp {
fn update(&mut self, ctx: &Context, _frame: &mut eframe::Frame) { fn update(&mut self, ctx: &Context, _frame: &mut eframe::Frame) {
if matches!(self.server_status, ServerStatus::Connected) && !self.timer_started { if matches!(self.server_status, ServerStatus::Connected) && !self.timer_started {
@@ -134,7 +112,6 @@ impl eframe::App for P2PClientApp {
self.timer_started = true; self.timer_started = true;
} }
// in update (every frame)
let now = std::time::Instant::now(); let now = std::time::Instant::now();
let delta = now.saturating_duration_since(self.last_update); let delta = now.saturating_duration_since(self.last_update);
self.last_update = now; self.last_update = now;
@@ -145,18 +122,8 @@ impl eframe::App for P2PClientApp {
self.remaining = self.remaining.saturating_sub(delta); self.remaining = self.remaining.saturating_sub(delta);
} }
// 1. Process incoming Network Events
// We poll the channel and update the GUI state for every event received.
while let Ok(event) = self.network_event_rx.try_recv() { while let Ok(event) = self.network_event_rx.try_recv() {
match event { match event {
NetworkEvent::PeerConnected(addr) => {
todo!();
self.status_message = format!("✅ Peer connected: {}", addr);
if !self.known_peers.contains(&(addr, true)) {
self.known_peers.push((addr, true));
}
}
NetworkEvent::RootRequest(addr) => { NetworkEvent::RootRequest(addr) => {
let root = self.shared_tree.root; let root = self.shared_tree.root;
let _ = self let _ = self
@@ -182,8 +149,6 @@ impl eframe::App for P2PClientApp {
} }
} }
NetworkEvent::PeerListUpdated(peers) => { NetworkEvent::PeerListUpdated(peers) => {
//todo!();
self.known_peers = peers; self.known_peers = peers;
} }
@@ -223,14 +188,6 @@ impl eframe::App for P2PClientApp {
} }
} }
NetworkEvent::FileTreeRootReceived(peer_id, root_hash) => { NetworkEvent::FileTreeRootReceived(peer_id, root_hash) => {
// todo!();
/*self.status_message = format!(
"🔄 Received Merkle Root from {}: {}",
peer_id,
&root_hash[..8]
);*/
if let Ok(chunknode) = ChunkNode::new(Vec::new()) { if let Ok(chunknode) = ChunkNode::new(Vec::new()) {
let data_map: HashMap<NodeHash, MerkleNode> = HashMap::new(); let data_map: HashMap<NodeHash, MerkleNode> = HashMap::new();
//data_map.insert(root_hash, MerkleNode::Chunk(chunknode)); //data_map.insert(root_hash, MerkleNode::Chunk(chunknode));
@@ -249,13 +206,6 @@ impl eframe::App for P2PClientApp {
println!("tree created"); println!("tree created");
} }
//self.active_peer_id = Some(peer_id.clone());
// Request the content of the root directory immediately
/*let _ = self
.network_cmd_tx
.send(NetworkCommand::RequestDirectoryContent(peer_id, root_hash));*/
} }
NetworkEvent::Connected(ip) => { NetworkEvent::Connected(ip) => {
self.server_status = ServerStatus::Connected; self.server_status = ServerStatus::Connected;
@@ -311,11 +261,11 @@ impl eframe::App for P2PClientApp {
true, true,
)); ));
self.remaining_chunks.insert(entry); self.remaining_chunks.insert(entry);
self.set_current_total_chunks(Some(self.remaining_chunks.len())); self.current_total_chunks = Some(self.remaining_chunks.len());
} }
self.remaining_chunks.remove(&hash); self.remaining_chunks.remove(&hash);
} }
MerkleNode::Chunk(chunk) => { MerkleNode::Chunk(_) => {
self.remaining_chunks.remove(&hash); self.remaining_chunks.remove(&hash);
} }
_ => {} _ => {}
@@ -328,30 +278,6 @@ impl eframe::App for P2PClientApp {
} }
if self.remaining_chunks.is_empty() { if self.remaining_chunks.is_empty() {
/*let file = OpenOptions::new()
.append(true)
.create(true)
.open(self.root_downloading_file.clone());
if let Some(current) = self
.current_downloading_file_map
.data
.get(&self.current_downloading_file_map.root)
{
match file {
Ok(mut fileok) => {
big_or_chunk_to_file(
&self.current_downloading_file_map,
current,
&mut fileok,
);
}
Err(e) => {
eprintln!("error creaation file: {}", e);
}
}
}*/
self.current_total_chunks = None;
self.current_received_chunks = 0; self.current_received_chunks = 0;
println!("bigfile téléchargé"); println!("bigfile téléchargé");
} }
@@ -366,25 +292,26 @@ impl eframe::App for P2PClientApp {
self.server_status = ServerStatus::NotConnected; self.server_status = ServerStatus::NotConnected;
let err_msg = format!("Failed to connect to the server: {}", err); let err_msg = format!("Failed to connect to the server: {}", err);
self.show_error(err_msg, ""); self.show_error(err_msg, "");
let res = self.network_cmd_tx.send(NetworkCommand::ResetServerPeer()); match self.network_cmd_tx.send(NetworkCommand::ResetServerPeer()) {
Ok(_) => {}
Err(err) => {
println!("GUI Error : {}", err.to_string());
}
};
} }
} }
} }
if self.show_choose_server_window { if self.show_choose_server_window {
let full_rect = ctx.input(|i| i.screen_rect()); let full_rect = ctx.input(|i| i.content_rect());
let modal_size = egui::vec2(400.0, 160.0); let modal_size = egui::vec2(400.0, 160.0);
let modal_pos = (full_rect.center() - modal_size * 0.5).to_vec2();
// 1) blocker (background order) — captures input except modal area
egui::Area::new(Id::new("modal_blocker_bg")) egui::Area::new(Id::new("modal_blocker_bg"))
.order(egui::Order::Background) .order(egui::Order::Background)
.show(ctx, |ui| { .show(ctx, |ui| {
let painter = ui.painter(); let painter = ui.painter();
painter.rect_filled(full_rect, 0.0, egui::Color32::from_black_alpha(160)); painter.rect_filled(full_rect, 0.0, egui::Color32::from_black_alpha(160));
// create an interactable that covers the full rect so clicks are eaten
// but leave the modal rect uncovered by marking it non-interactive below.
let sense = egui::Sense::click_and_drag(); let sense = egui::Sense::click_and_drag();
ui.allocate_exact_size(full_rect.size(), sense); ui.allocate_exact_size(full_rect.size(), sense);
}); });
@@ -437,12 +364,17 @@ impl eframe::App for P2PClientApp {
// use resp (click handling etc.) // use resp (click handling etc.)
if resp.clicked() { if resp.clicked() {
self.active_server = peer.0.to_string(); self.active_server = peer.0.to_string();
let res = self.network_cmd_tx.send( match self.network_cmd_tx.send(
NetworkCommand::ServerHandshake( NetworkCommand::ServerHandshake(
peer.0.to_string(), peer.0.to_string(),
self.connected_address.clone(), self.connected_address.clone(),
), ),
); ) {
Ok(_) => {}
Err(e) => {
println!("GUI Error : {}", e.to_string());
}
};
ui.close(); ui.close();
self.show_choose_server_window = false; self.show_choose_server_window = false;
} }
@@ -457,60 +389,13 @@ impl eframe::App for P2PClientApp {
TopBottomPanel::top("top_panel").show(ctx, |ui| { TopBottomPanel::top("top_panel").show(ctx, |ui| {
egui::MenuBar::new().ui(ui, |ui| { egui::MenuBar::new().ui(ui, |ui| {
ui.menu_button("File", |ui| { ui.menu_button("File", |ui| {
if ui.button("Settings").clicked() { if ui.button("Settings").clicked() {}
//show settings
}
if ui.button("Quit").clicked() { if ui.button("Quit").clicked() {
// Use ViewportCommand to request a close
ctx.send_viewport_cmd(ViewportCommand::Close); ctx.send_viewport_cmd(ViewportCommand::Close);
} }
}); });
//ui.menu_button("Network", |ui| {
// match self.server_status {
// ServerStatus::Connected | ServerStatus::ConnectedHandshake => {
// let desired = egui::vec2(300.0, 0.0); // width 300, auto-height if 0
// ui.set_min_size(desired);
// ui.vertical(|ui| {
// if ui.button("Disconnect").clicked() {
// println!("Disconnecting...");
// let _ = self.network_cmd_tx.send(NetworkCommand::Disconnect());
// self.server_status = ServerStatus::NotConnected;
// self.remaining = std::time::Duration::from_secs(0);
// self.timer_started = false;
// ui.close();
// }
// });
// }
// ServerStatus::NotConnected => {
// let desired = egui::vec2(0.0, 0.0); // width 300, auto-height if 0
// ui.set_min_size(desired);
// ui.vertical(|ui| {
// ui.horizontal(|ui| {
// ui.label("Server IP:");
// ui.text_edit_singleline(&mut self.connect_address_input);
// });
// ui.horizontal(|ui| {
// ui.label("Name:");
// ui.text_edit_singleline(&mut self.connect_name_input);
// });
// if ui.button("Connect").clicked() {
// let addr = self.connect_address_input.clone();
// let name = self.connect_name_input.clone();
// let _ = self
// .network_cmd_tx
// .send(NetworkCommand::ConnectToServerPut(addr, name));
// self.server_status = ServerStatus::Loading;
// ui.close();
// }
// });
// }
// _ => {}
// }
//});
// open trigger (e.g., in a menu bar)
if ui.button("Network").clicked() { if ui.button("Network").clicked() {
self.show_network_window = true; self.show_network_window = true;
} }
@@ -636,41 +521,9 @@ impl eframe::App for P2PClientApp {
let is_active = let is_active =
self.active_peer.as_ref().map_or(false, |id| id == &peer.0); // if peer.id == self.active_peer_id self.active_peer.as_ref().map_or(false, |id| id == &peer.0); // if peer.id == self.active_peer_id
let selectable: Response;
// if &self.active_server == &peer.0 {
// // Create a frame with green background and render the selectable inside it.
// // Adjust rounding, padding and stroke as desired.
// let frame = Frame {
// fill: Color32::DARK_BLUE,
// stroke: Stroke::default(),
// corner_radius: CornerRadius::from(0.5),
// ..Default::default()
// };
// let internal = frame.show(ui, |ui| {
// // horizontal row: label on the left, spinner on the right
// ui.horizontal(|ui| {
// // let selectable label take remaining space
// ui.with_layout(Layout::left_to_right(Align::Center), |ui| {
// ui.add_space(0.0); // ensure layout established
// return ui.selectable_label(
// is_active,
// format!("{}", peer.0),
// );
// })
// .inner // return Response from the inner closure if your egui version does so
// })
// });
// selectable = internal.inner.inner;
// } else {
// selectable = ui.selectable_label(is_active, format!("{}", peer.0));
// }
// place spinner to the right of the label // place spinner to the right of the label
ui.horizontal(|ui| { ui.horizontal(|ui| {
// Use same width for the label widget as the selectable we already created:
// Recreate selectable inline so both label and spinner share the same row.
let resp = if &self.active_server == &peer.0 { let resp = if &self.active_server == &peer.0 {
// draw with frame inline
let frame = Frame { let frame = Frame {
fill: Color32::DARK_BLUE, fill: Color32::DARK_BLUE,
stroke: Stroke::default(), stroke: Stroke::default(),
@@ -692,7 +545,6 @@ impl eframe::App for P2PClientApp {
ui.add_space(4.0); // small gap ui.add_space(4.0); // small gap
if self.loading_peers.contains(&peer.0) { if self.loading_peers.contains(&peer.0) {
// push spinner to right by expanding a spacer before it
ui.with_layout( ui.with_layout(
Layout::right_to_left(Align::Center), Layout::right_to_left(Align::Center),
|ui| { |ui| {
@@ -701,9 +553,7 @@ impl eframe::App for P2PClientApp {
); );
} }
// use resp (click handling etc.)
if resp.clicked() { if resp.clicked() {
// switch to displaying this peer's tree
self.active_peer = Some(peer.0.clone()); self.active_peer = Some(peer.0.clone());
// Request root content if not loaded // Request root content if not loaded
if !self if !self
@@ -720,7 +570,6 @@ impl eframe::App for P2PClientApp {
} }
} }
resp.context_menu(|ui| { resp.context_menu(|ui| {
// ... action
match self.server_status { match self.server_status {
ServerStatus::Connected => { ServerStatus::Connected => {
if ui if ui
@@ -728,12 +577,17 @@ impl eframe::App for P2PClientApp {
.clicked() .clicked()
{ {
self.active_server = peer.0.to_string(); self.active_server = peer.0.to_string();
let res = self.network_cmd_tx.send( match self.network_cmd_tx.send(
NetworkCommand::ServerHandshake( NetworkCommand::ServerHandshake(
peer.0.to_string(), peer.0.to_string(),
self.connected_address.clone(), self.connected_address.clone(),
), ),
); ) {
Ok(_) => {}
Err(e) => {
println!("GUI Error : {}", e.to_string());
},
};
} }
} }
_ => {} _ => {}

1
client-network/src/lib.rs
View File

@@ -196,7 +196,6 @@ pub enum NetworkEvent {
Disconnected(), Disconnected(),
Error(String, String), Error(String, String),
Success(String, String), Success(String, String),
PeerConnected(String),
PeerListUpdated(Vec<(String, bool)>), PeerListUpdated(Vec<(String, bool)>),
FileTreeReceived([u8; 32], MerkleNode, String), // peer_id, content FileTreeReceived([u8; 32], MerkleNode, String), // peer_id, content
DataReceived([u8; 32], MerkleNode, String), DataReceived([u8; 32], MerkleNode, String),