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::{
ChunkNode, MerkleNode, MerkleTree, NetworkCommand, NetworkEvent, NodeHash,
big_or_chunk_to_file, filename_to_string, generate_base_tree, node_hash_to_hex_string,
node_to_file, remove_null_bytes,
big_or_chunk_to_file, generate_base_tree, node_hash_to_hex_string, remove_null_bytes,
};
use crossbeam_channel::{Receiver, Sender};
use egui::{
Align, CentralPanel, CollapsingHeader, Color32, Context, CornerRadius, Frame, Id, Layout,
ProgressBar, Response, ScrollArea, SidePanel, Stroke, TopBottomPanel, Ui, Vec2,
ViewportCommand,
ProgressBar, Response, ScrollArea, SidePanel, Stroke, TopBottomPanel, Ui, ViewportCommand,
};
use std::collections::HashMap;
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 {
Loading,
@@ -21,24 +19,19 @@ enum ServerStatus {
ConnectedHandshake,
}
// --- Main Application Struct ---
pub struct P2PClientApp {
remaining: std::time::Duration, // temps restant
last_update: std::time::Instant, // pour calculer delta
timer_started: bool,
// Communication channels
network_cmd_tx: Sender<NetworkCommand>,
network_event_rx: Receiver<NetworkEvent>,
// GUI State
status_message: String,
known_peers: Vec<(String, bool)>,
loading_peers: Vec<String>,
connect_address_input: String,
connected_address: String,
connect_name_input: String,
// Key: Parent Directory Hash (String), Value: List of children FileNode
loaded_fs: HashMap<String, MerkleTree>,
shared_tree: MerkleTree,
@@ -67,12 +60,8 @@ pub struct P2PClientApp {
impl P2PClientApp {
pub fn new(cmd_tx: Sender<NetworkCommand>, event_rx: Receiver<NetworkEvent>) -> Self {
//let (root_hash, tree_content) = MerkleNode::generate_base_tree();
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);
let loaded_fs = HashMap::new();
let current_downloading_file_map = MerkleTree::new(HashMap::new(), [0; 32]);
Self {
remaining: std::time::Duration::from_secs(0),
@@ -80,7 +69,6 @@ impl P2PClientApp {
last_update: std::time::Instant::now(),
network_cmd_tx: cmd_tx,
network_event_rx: event_rx,
status_message: "Client Initialized. Awaiting network status...".to_string(),
known_peers: Vec::new(),
loading_peers: Vec::new(),
connect_address_input: "https://jch.irif.fr:8443".to_string(),
@@ -114,18 +102,8 @@ 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 ---
impl eframe::App for P2PClientApp {
fn update(&mut self, ctx: &Context, _frame: &mut eframe::Frame) {
if matches!(self.server_status, ServerStatus::Connected) && !self.timer_started {
@@ -134,7 +112,6 @@ impl eframe::App for P2PClientApp {
self.timer_started = true;
}
// in update (every frame)
let now = std::time::Instant::now();
let delta = now.saturating_duration_since(self.last_update);
self.last_update = now;
@@ -145,18 +122,8 @@ impl eframe::App for P2PClientApp {
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() {
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) => {
let root = self.shared_tree.root;
let _ = self
@@ -182,8 +149,6 @@ impl eframe::App for P2PClientApp {
}
}
NetworkEvent::PeerListUpdated(peers) => {
//todo!();
self.known_peers = peers;
}
@@ -223,14 +188,6 @@ impl eframe::App for P2PClientApp {
}
}
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()) {
let data_map: HashMap<NodeHash, MerkleNode> = HashMap::new();
//data_map.insert(root_hash, MerkleNode::Chunk(chunknode));
@@ -249,13 +206,6 @@ impl eframe::App for P2PClientApp {
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) => {
self.server_status = ServerStatus::Connected;
@@ -311,11 +261,11 @@ impl eframe::App for P2PClientApp {
true,
));
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);
}
MerkleNode::Chunk(chunk) => {
MerkleNode::Chunk(_) => {
self.remaining_chunks.remove(&hash);
}
_ => {}
@@ -328,30 +278,6 @@ impl eframe::App for P2PClientApp {
}
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;
println!("bigfile téléchargé");
}
@@ -366,25 +292,26 @@ impl eframe::App for P2PClientApp {
self.server_status = ServerStatus::NotConnected;
let err_msg = format!("Failed to connect to the server: {}", err);
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 {
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_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"))
.order(egui::Order::Background)
.show(ctx, |ui| {
let painter = ui.painter();
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();
ui.allocate_exact_size(full_rect.size(), sense);
});
@@ -437,12 +364,17 @@ impl eframe::App for P2PClientApp {
// use resp (click handling etc.)
if resp.clicked() {
self.active_server = peer.0.to_string();
let res = self.network_cmd_tx.send(
match self.network_cmd_tx.send(
NetworkCommand::ServerHandshake(
peer.0.to_string(),
self.connected_address.clone(),
),
);
) {
Ok(_) => {}
Err(e) => {
println!("GUI Error : {}", e.to_string());
}
};
ui.close();
self.show_choose_server_window = false;
}
@@ -457,60 +389,13 @@ impl eframe::App for P2PClientApp {
TopBottomPanel::top("top_panel").show(ctx, |ui| {
egui::MenuBar::new().ui(ui, |ui| {
ui.menu_button("File", |ui| {
if ui.button("Settings").clicked() {
//show settings
}
if ui.button("Settings").clicked() {}
if ui.button("Quit").clicked() {
// Use ViewportCommand to request a 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() {
self.show_network_window = true;
}
@@ -636,41 +521,9 @@ impl eframe::App for P2PClientApp {
let is_active =
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
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 {
// draw with frame inline
let frame = Frame {
fill: Color32::DARK_BLUE,
stroke: Stroke::default(),
@@ -692,7 +545,6 @@ impl eframe::App for P2PClientApp {
ui.add_space(4.0); // small gap
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| {
@@ -701,9 +553,7 @@ impl eframe::App for P2PClientApp {
);
}
// use resp (click handling etc.)
if resp.clicked() {
// switch to displaying this peer's tree
self.active_peer = Some(peer.0.clone());
// Request root content if not loaded
if !self
@@ -720,7 +570,6 @@ impl eframe::App for P2PClientApp {
}
}
resp.context_menu(|ui| {
// ... action
match self.server_status {
ServerStatus::Connected => {
if ui
@@ -728,12 +577,17 @@ impl eframe::App for P2PClientApp {
.clicked()
{
self.active_server = peer.0.to_string();
let res = self.network_cmd_tx.send(
match self.network_cmd_tx.send(
NetworkCommand::ServerHandshake(
peer.0.to_string(),
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(),
Error(String, String),
Success(String, String),
PeerConnected(String),
PeerListUpdated(Vec<(String, bool)>),
FileTreeReceived([u8; 32], MerkleNode, String), // peer_id, content
DataReceived([u8; 32], MerkleNode, String),