root request

client-network/src/lib.rs

@@ -12,7 +12,7 @@ use crate::{
     cryptographic_signature::CryptographicSignature,
     message_handling::EventType,
     messages_channels::{MultipleSenders, start_receving_thread},
-    messages_structure::construct_message,
+    messages_structure::{ROOTREQUEST, construct_message},
     peers_refresh::HandshakeHistory,
     registration::{
         get_socket_address, parse_addresses, perform_handshake, register_with_the_server,
@@ -123,7 +123,7 @@ pub enum NetworkCommand {
     RequestChunk(String, String),
     Disconnect(),
     ResetServerPeer(),
-    Discover(String, String),
+    Discover(String, String, String),
     GetChildren(String, String),
     // ...
 }
@@ -138,7 +138,7 @@ pub enum NetworkEvent {
     PeerListUpdated(Vec<String>),
     FileTreeReceived(String, Vec<MerkleNode>), // peer_id, content
     DataReceived(String, MerkleNode),
-    FileTreeRootReceived(String, String),
+    FileTreeRootReceived(String, NodeHash),
     HandshakeFailed(),
     ServerHandshakeFailed(String),
     // ...
@@ -173,6 +173,8 @@ pub fn start_p2p_executor(
     // Use tokio to spawn the asynchronous networking logic
     tokio::task::spawn(async move {
         // P2P/Networking Setup goes here
+        let handshake_history = Arc::new(Mutex::new(HandshakeHistory::new()));
+        let handshake_clone = handshake_history.clone();
 
         println!("Network executor started.");
 
@@ -182,12 +184,13 @@ pub fn start_p2p_executor(
             if let Ok(cmd) = cmd_rx.try_recv() {
                 match cmd {
                     NetworkCommand::ServerHandshake(username, ip) => {
+                        println!("server handshake called");
                         if let Some(sd) = shared_data.as_ref() {
-                            start_receving_thread(
-                                sd,
-                                event_tx.clone(), //
-                            );
-                            perform_handshake(&sd, username, ip, event_tx.clone());
+                            start_receving_thread(sd, event_tx.clone(), &handshake_clone);
+                            let res =
+                                perform_handshake(&sd, username, ip, event_tx.clone(), true).await;
+                        } else {
+                            println!("no shared data");
                         }
                     }
                     NetworkCommand::ConnectPeer(addr) => {
@@ -200,8 +203,52 @@ pub fn start_p2p_executor(
                     NetworkCommand::RequestFileTree(_) => {
                         println!("[Network] RequestFileTree() called");
                     }
-                    NetworkCommand::Discover(username, hash) => {
+                    NetworkCommand::Discover(username, hash, ip) => {
                         // envoie un handshake au peer, puis un root request
+                        if let Some(sd) = shared_data.as_ref() {
+                            let res = {
+                                let m = handshake_clone.lock().unwrap();
+                                m.get_peer_info_username(username.clone()).cloned()
+                            };
+                            match res {
+                                Some(peerinfo) => {
+                                    // envoyer un root request
+                                    let rootrequest = construct_message(
+                                        ROOTREQUEST,
+                                        Vec::new(),
+                                        generate_id(),
+                                        sd.cryptopair_ref(),
+                                    );
+
+                                    match rootrequest {
+                                        None => {}
+                                        Some(resp_msg) => {
+                                            println!("msg_sent:{:?}", resp_msg);
+                                            sd.senders_ref().send_via(
+                                                0,
+                                                resp_msg,
+                                                peerinfo.ip.to_string(),
+                                                false,
+                                                sd.messages_list_ref(),
+                                            );
+                                        }
+                                    }
+                                }
+                                None => {
+                                    // envoyer un handshake
+                                    let res = perform_handshake(
+                                        &sd,
+                                        username,
+                                        ip,
+                                        event_tx.clone(),
+                                        false,
+                                    )
+                                    .await;
+                                }
+                            }
+                        } else {
+                            println!("no shared data");
+                        }
                     }
                     NetworkCommand::GetChildren(username, hash) => {
                         // envoie un datum request au peer