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

Compare commits

base: bob:address_fetch_fix
Branches Tags
bob:master bob:bigfix bob:address_fetch_fix bob:download_progress bob:nat_transversal bob:tmp
..
compare: bob:download_progress
Branches Tags
bob:master bob:bigfix bob:address_fetch_fix bob:download_progress bob:nat_transversal bob:tmp

1 Commits
address_fe ... download_p

Author SHA1 Message Date
Tiago Batista Cardoso
fc7886c94c progress bar 2026-01-25 00:54:54 +01:00
4 changed files with 285 additions and 216 deletions
Expand all files Collapse all files

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

@@ -1,16 +1,18 @@
use client_network::{ use client_network::{
ChunkNode, MerkleNode, MerkleTree, NetworkCommand, NetworkEvent, NodeHash, ChunkNode, MerkleNode, MerkleTree, NetworkCommand, NetworkEvent, NodeHash,
big_or_chunk_to_file, generate_base_tree, node_hash_to_hex_string, remove_null_bytes, big_or_chunk_to_file, filename_to_string, generate_base_tree, node_hash_to_hex_string,
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, Layout,
ProgressBar, ScrollArea, SidePanel, Stroke, TopBottomPanel, Ui, ViewportCommand, ProgressBar, Response, ScrollArea, SidePanel, Stroke, TopBottomPanel, Ui, Vec2,
ViewportCommand,
}; };
use std::collections::HashMap;
use std::collections::HashSet; use std::collections::HashSet;
use std::{collections::HashMap, fmt::format, io::Seek};
use std::fs::{OpenOptions, create_dir}; use std::fs::{File, OpenOptions, create_dir};
enum ServerStatus { enum ServerStatus {
Loading, Loading,
@@ -19,19 +21,24 @@ 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,
@@ -40,6 +47,8 @@ pub struct P2PClientApp {
server_status: ServerStatus, server_status: ServerStatus,
show_network_popup: bool, // gérer selon besoin
error_message: Option<(String, String)>, // Some(message) -> afficher, None -> rien error_message: Option<(String, String)>, // Some(message) -> afficher, None -> rien
success_message: Option<(String, String)>, // Some(message) -> afficher, None -> rien success_message: Option<(String, String)>, // Some(message) -> afficher, None -> rien
active_server: String, active_server: String,
@@ -54,14 +63,16 @@ pub struct P2PClientApp {
current_received_chunks: usize, current_received_chunks: usize,
root_downloading_file: String, root_downloading_file: String,
show_network_window: bool,
show_choose_server_window: bool,
} }
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 loaded_fs = HashMap::new(); //let (root_hash, tree_content) = MerkleNode::generate_base_tree();
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),
@@ -69,6 +80,7 @@ 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(),
@@ -76,6 +88,7 @@ impl P2PClientApp {
loaded_fs, loaded_fs,
active_peer: None, active_peer: None,
server_status: ServerStatus::NotConnected, server_status: ServerStatus::NotConnected,
show_network_popup: false,
error_message: None, error_message: None,
success_message: None, success_message: None,
connect_name_input: "bob".to_string(), connect_name_input: "bob".to_string(),
@@ -86,8 +99,6 @@ impl P2PClientApp {
current_received_chunks: 0, current_received_chunks: 0,
root_downloading_file: "".to_string(), root_downloading_file: "".to_string(),
remaining_chunks: HashSet::new(), remaining_chunks: HashSet::new(),
show_network_window: false,
show_choose_server_window: false,
} }
} }
pub fn show_error(&mut self, msg: impl Into<String>, peer_username: impl Into<String>) { pub fn show_error(&mut self, msg: impl Into<String>, peer_username: impl Into<String>) {
@@ -102,8 +113,18 @@ 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 {
@@ -112,6 +133,7 @@ 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;
@@ -122,8 +144,18 @@ 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
@@ -149,6 +181,8 @@ impl eframe::App for P2PClientApp {
} }
} }
NetworkEvent::PeerListUpdated(peers) => { NetworkEvent::PeerListUpdated(peers) => {
//todo!();
self.known_peers = peers; self.known_peers = peers;
} }
@@ -188,6 +222,14 @@ 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));
@@ -206,11 +248,17 @@ 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;
self.connected_address = ip.clone(); self.connected_address = ip.clone();
self.show_choose_server_window = true;
let _ = self.network_cmd_tx.send(NetworkCommand::FetchPeerList( let _ = self.network_cmd_tx.send(NetworkCommand::FetchPeerList(
self.connected_address.clone(), self.connected_address.clone(),
)); ));
@@ -261,11 +309,11 @@ impl eframe::App for P2PClientApp {
true, true,
)); ));
self.remaining_chunks.insert(entry); self.remaining_chunks.insert(entry);
self.current_total_chunks = Some(self.remaining_chunks.len()); self.set_current_total_chunks(Some(self.remaining_chunks.len()));
} }
self.remaining_chunks.remove(&hash); self.remaining_chunks.remove(&hash);
} }
MerkleNode::Chunk(_) => { MerkleNode::Chunk(chunk) => {
self.remaining_chunks.remove(&hash); self.remaining_chunks.remove(&hash);
} }
_ => {} _ => {}
@@ -278,6 +326,29 @@ 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_total_chunks = None;
self.current_received_chunks = 0; self.current_received_chunks = 0;
println!("bigfile téléchargé"); println!("bigfile téléchargé");
@@ -293,115 +364,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, "");
match self.network_cmd_tx.send(NetworkCommand::ResetServerPeer()) { let res = 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.content_rect());
let modal_size = egui::vec2(400.0, 160.0);
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));
let sense = egui::Sense::click_and_drag();
ui.allocate_exact_size(full_rect.size(), sense);
});
egui::Window::new("Choose the server")
.resizable(false)
.collapsible(false)
.title_bar(true)
.anchor(egui::Align2::CENTER_CENTER, egui::Vec2::ZERO)
.fixed_size(modal_size)
.show(ctx, |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.");
} else {
for peer in &self.known_peers {
let is_active =
self.active_peer.as_ref().map_or(false, |id| id == &peer.0); // if peer.id == self.active_peer_id
// 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(),
corner_radius: CornerRadius::from(0.5),
..Default::default()
};
frame
.show(ui, |ui| {
ui.selectable_label(
is_active,
format!("{}", peer.0),
)
})
.inner
} else {
ui.selectable_label(is_active, format!("{}", peer.0))
};
ui.add_space(4.0); // small gap
// use resp (click handling etc.)
if resp.clicked() {
self.active_server = peer.0.to_string();
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;
}
});
}
}
});
});
}
// 2. Menu Bar // 2. Menu Bar
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);
} }
}); });
if ui.button("Network").clicked() { ui.menu_button("Network", |ui| {
self.show_network_window = true;
}
if self.show_network_window {
match self.server_status { match self.server_status {
ServerStatus::Connected | ServerStatus::ConnectedHandshake => { ServerStatus::Connected | ServerStatus::ConnectedHandshake => {
let desired = egui::vec2(300.0, 0.0); // width 300, auto-height if 0 let desired = egui::vec2(300.0, 0.0); // width 300, auto-height if 0
@@ -413,14 +395,14 @@ impl eframe::App for P2PClientApp {
self.server_status = ServerStatus::NotConnected; self.server_status = ServerStatus::NotConnected;
self.remaining = std::time::Duration::from_secs(0); self.remaining = std::time::Duration::from_secs(0);
self.timer_started = false; self.timer_started = false;
self.show_network_window = false; ui.close();
} }
}); });
} }
ServerStatus::NotConnected => { ServerStatus::NotConnected => {
egui::Window::new("Network") let desired = egui::vec2(0.0, 0.0); // width 300, auto-height if 0
.resizable(false) ui.set_min_size(desired);
.show(ctx, |ui| { ui.vertical(|ui| {
ui.horizontal(|ui| { ui.horizontal(|ui| {
ui.label("Server IP:"); ui.label("Server IP:");
ui.text_edit_singleline(&mut self.connect_address_input); ui.text_edit_singleline(&mut self.connect_address_input);
@@ -432,23 +414,17 @@ impl eframe::App for P2PClientApp {
if ui.button("Connect").clicked() { if ui.button("Connect").clicked() {
let addr = self.connect_address_input.clone(); let addr = self.connect_address_input.clone();
let name = self.connect_name_input.clone(); let name = self.connect_name_input.clone();
let _ = self.network_cmd_tx.send( let _ = self
NetworkCommand::ConnectToServerPut( .network_cmd_tx
addr, .send(NetworkCommand::ConnectToServerPut(addr, name));
name.to_string(),
),
);
self.server_status = ServerStatus::Loading; self.server_status = ServerStatus::Loading;
ui.close(); ui.close();
self.show_network_window = false;
self.loaded_fs
.insert(name.to_string(), self.shared_tree.clone());
} }
}); });
} }
_ => {} _ => {}
} }
} });
}); });
}); });
@@ -526,22 +502,42 @@ impl eframe::App for P2PClientApp {
for peer in &self.known_peers { for peer in &self.known_peers {
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
//
if peer.0.eq(&self.connect_name_input) {
ui.horizontal(|ui| {
let resp = ui.selectable_label(
is_active,
format!("{} (you)", peer.0),
);
if resp.clicked() { let selectable: Response;
self.active_peer = Some(peer.0.clone()); // 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.
} else { // 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(),
@@ -563,6 +559,7 @@ 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| {
@@ -571,7 +568,9 @@ 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
@@ -579,16 +578,16 @@ impl eframe::App for P2PClientApp {
.contains_key(self.active_peer.as_ref().unwrap()) .contains_key(self.active_peer.as_ref().unwrap())
{ {
//todo!(); //todo!();
let _ = self.network_cmd_tx.send( let _ =
NetworkCommand::Discover( self.network_cmd_tx.send(NetworkCommand::Discover(
peer.0.clone(), peer.0.clone(),
"root".to_string(), "root".to_string(),
self.connected_address.clone(), self.connected_address.clone(),
), ));
);
} }
} }
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
@@ -596,17 +595,12 @@ impl eframe::App for P2PClientApp {
.clicked() .clicked()
{ {
self.active_server = peer.0.to_string(); self.active_server = peer.0.to_string();
match self.network_cmd_tx.send( let res = 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());
},
};
} }
} }
_ => {} _ => {}
@@ -644,7 +638,74 @@ impl eframe::App for P2PClientApp {
// ... autres boutons // ... autres boutons
}); });
}); });
}
// if self.loading_peers.contains(&peer.0) {
// ui.spinner();
// }
//if selectable.clicked() {
// switch to displaying this peer's tree
//self.active_peer = Some(peer.0.clone());
//// Request root content if not loaded
//if !self
// .loaded_fs
// .contains_key(self.active_peer.as_ref().unwrap())
//{
// //todo!();
// let _ = self.network_cmd_tx.send(NetworkCommand::Discover(
// peer.0.clone(),
// "root".to_string(),
// self.connected_address.clone(),
// ));
//}
//}
//selectable.context_menu(|ui| {
// // ... action
// match self.server_status {
// ServerStatus::Connected => {
// if ui
// .button("Utiliser le peer en tant que serveur")
// .clicked()
// {
// self.active_server = peer.0.to_string();
// let res = self.network_cmd_tx.send(
// NetworkCommand::ServerHandshake(
// peer.0.to_string(),
// self.connected_address.clone(),
// ),
// );
// }
// }
// _ => {}
// }
// if ui.button("Send Ping").clicked() {
// let res = self.network_cmd_tx.send(NetworkCommand::Ping(
// peer.0.to_string(),
// self.connected_address.clone(),
// ));
// self.loading_peers.push(peer.0.to_owned());
// }
// if ui.button("Send Nat Traversal Request").clicked() {
// match self.network_cmd_tx.send(NetworkCommand::NatTraversal(
// peer.0.to_string(),
// self.connected_address.clone(),
// )) {
// Ok(_) => {
// print!("[+] successfully sent nat traversal request")
// }
// Err(_) => {
// print!("[-] failed to send nat traversal request")
// }
// }
// }
// if ui.button("Infos").clicked() {
// // action 3
// ui.close();
// }
// // ... autres boutons
//});
} }
} }
}); });

2
client-gui/src/main.rs
View File

@@ -32,7 +32,7 @@ async fn main() -> eframe::Result<()> {
eframe::run_native( eframe::run_native(
"p2p-merkle client", "p2p-merkle client",
options, options,
Box::new(|_| { Box::new(|cc| {
let app = P2PClientApp::new(network_cmd_tx, network_event_rx); let app = P2PClientApp::new(network_cmd_tx, network_event_rx);
Ok(Box::new(app)) Ok(Box::new(app))
}), }),

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

@@ -196,6 +196,7 @@ 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),
@@ -576,21 +577,14 @@ pub fn start_p2p_executor(
current.push(i); current.push(i);
} }
} }
match event_tx.send(NetworkEvent::PeerListUpdated(peers)) { let res =
Ok(_) => {} event_tx.send(NetworkEvent::PeerListUpdated(peers));
Err(err) => {
println!(
"Network Event Error : {}",
err.to_string()
);
}
};
} }
Err(e) => { Err(e) => {
eprintln!("invalid UTF-8 in socket address bytes: {}", e); eprintln!("invalid UTF-8 in socket address bytes: {}", e);
} }
}, },
Err(e) => println!("error : {}", e), Err(e) => println!("error"),
} }
} }
} }
@@ -602,10 +596,25 @@ pub fn start_p2p_executor(
if let Some(sd) = shared_data.as_ref() { if let Some(sd) = shared_data.as_ref() {
let id = generate_id(); let id = generate_id();
sd.add_message(id, EventType::Ping); sd.add_message(id, EventType::Ping);
let pingrequest =
construct_message(PING, Vec::new(), id, sd.cryptopair_ref());
let peer_address = let peer_address =
get_socket_address(str.to_owned(), ip, shared_data.as_ref()).await; get_socket_address(str.to_owned(), ip, shared_data.as_ref()).await;
match peer_address { match peer_address {
Ok(addr) => { Ok(addr) => {
//if let Some(ping) = pingrequest {
// sd.senders_ref().add_message_to_retry_queue(
// ping.clone(),
// addr.to_string(),
// false,
// );
// sd.senders_ref().send_dispatch(
// ping,
// addr.to_string(),
// false,
// sd.messages_list(),
// );
//}
match event_tx.send(NetworkEvent::Success( match event_tx.send(NetworkEvent::Success(
format!( format!(
"Successfully sent ping message to {}.", "Successfully sent ping message to {}.",

1
rapport.txt
View File

@@ -1 +0,0 @@
https://docs.google.com/document/d/1emhrAfjJyJTWpBYx4IJGcCz0_iLVjDRAAdq2EZFchKo/edit?usp=sharing