wip handling root request

client-network/src/peers_refresh.rs

@@ -11,54 +11,113 @@ use std::{
     time::{self, Duration, SystemTime},
 };
 
+use crate::NetworkEvent;
+use crate::{
+    P2PSharedData, construct_message, generate_id, messages_structure,
+    registration::perform_handshake,
+};
+use crossbeam_channel::{Receiver, Sender};
+use p256::ecdsa::VerifyingKey;
+
+#[derive(Debug, Clone)]
 pub struct PeerInfo {
     username: String,
-    ip: SocketAddr,
+    pub pubkey: VerifyingKey,
+    pub ip: SocketAddr,
 }
 
 pub struct HandshakeHistory {
-    time_k_ip_v: HashMap<u64, u64>,
-    ip_k_peerinfo_v: HashMap<u64, PeerInfo>,
+    //time_k_ip_v: HashMap<u64, u64>,
+    username_k_peerinfo_v: HashMap<String, PeerInfo>,
+    ip_k_peerinfo_v: HashMap<String, PeerInfo>,
 }
 
 impl HandshakeHistory {
     pub fn new() -> HandshakeHistory {
         HandshakeHistory {
-            time_k_ip_v: HashMap::new(),
+            //time_k_ip_v: HashMap::new(),
+            //ip_k_peerinfo_v: HashMap::new(),
+            username_k_peerinfo_v: HashMap::new(),
             ip_k_peerinfo_v: HashMap::new(),
         }
     }
 
-    pub fn update_handshake(&mut self) {
+    /*pub fn update_handshake(&self) {
+        let hashmap_shared = Arc::new(self.username_k_peerinfo_v);
         thread::spawn(move || {
-            let mut times_to_check = VecDeque::new();
-            let current_time: u64 = SystemTime::now()
-                .duration_since(time::UNIX_EPOCH)
-                .expect("system time before UNIX EPOCH")
-                .add(Duration::from_secs(10))
-                .as_secs();
-            // adds 10 seconds in the queue every 10 seconds
+            let selfhashmap = hashmap_shared.clone();
             loop {
-                let mut child = Command::new("sleep").arg("9").spawn().unwrap();
-                let _result = child.wait().unwrap();
-                for n in 0..9 {
-                    // push 9 successive seconds
-                    times_to_check.push_back(current_time + n);
-                    // gestion d'erreur si verrou mort
+                for peer in selfhashmap.keys() {
+                    let peer_ip = selfhashmap.get(peer);
+                    // send ping
                 }
+                let mut child = Command::new("sleep").arg("10").spawn().unwrap();
+                let _result = child.wait().unwrap();
+            }
+        });
+    }*/
+
+    pub fn get_peer_info_username(&self, username: String) -> Option<&PeerInfo> {
+        self.username_k_peerinfo_v.get(&username).clone()
+    }
+
+    pub fn get_peer_info_ip(&self, ip: String) -> Option<&PeerInfo> {
+        self.ip_k_peerinfo_v.get(&ip).clone()
+    }
+
+    pub fn update_handshake(&self) {
+        // clone the map so we own it (cheap if PeerInfo is Clone)
+        let map_clone: Arc<HashMap<String, PeerInfo>> =
+            Arc::new(self.username_k_peerinfo_v.clone());
+        //let map_ip_clone: Arc<HashMap<String, PeerInfo>> = Arc::new(self.ip_k_peerinfo_v.clone());
+        let map_for_thread = Arc::clone(&map_clone);
+        thread::spawn(move || {
+            loop {
+                // Arc<HashMap<..>> derefs to &HashMap so these reads work
+                for (peer, peerinfo) in map_for_thread.iter() {
+                    // send ping to peerinfo
+                }
+                thread::sleep(Duration::from_secs(10));
             }
         });
     }
 
-    pub fn add_new_handshake(&mut self, hash: u64, username: String, ip: SocketAddr) {
-        let current_time: u64 = SystemTime::now()
-            .duration_since(time::UNIX_EPOCH)
-            .expect("system time before UNIX EPOCH")
-            .as_secs();
-        println!("time:{}", current_time);
-        /*self.time_k_hash_v.insert(current_time, hash);
-        self.hash_k_peerinfo_v
-            .insert(hash, PeerInfo { username, ip });*/
+    pub fn add_new_handshake(&mut self, hash: VerifyingKey, username: String, ip: SocketAddr) {
+        let peerinfo = PeerInfo {
+            username: username.clone(),
+            pubkey: hash,
+            ip,
+        };
+        self.username_k_peerinfo_v
+            .insert(username, peerinfo.clone());
+        self.ip_k_peerinfo_v
+            .insert(ip.to_string(), peerinfo.clone());
+    }
+}
+
+pub fn perform_discover(
+    username: String,
+    hash: String,
+    sd: &P2PSharedData,
+    server_ip: String,
+    event_tx: Sender<NetworkEvent>,
+) {
+    // first, sends handshake
+    if hash == "root" {
+        perform_handshake(sd, username, server_ip, event_tx);
+        if let Some(data) = construct_message(
+            messages_structure::ROOTREQUEST,
+            Vec::new(),
+            generate_id(),
+            sd.cryptopair_ref(),
+        ) {
+            if let Some(peerinfo) = sd.handshake_ref() {
+                sd.senders_ref()
+                    .send_via(0, data, peerinfo.ip.to_string(), false);
+            }
+        }
+    } else {
+        // envoyer un datum request
     }
 }
 
@@ -68,10 +127,7 @@ mod tests {
 
     use super::*;
 
-    ///
-    /// creates a cryptographic signature
-    ///
-    #[test]
+    /*#[test]
     fn creating_cryptographic_signature() {
         let mut hh = HandshakeHistory::new();
         hh.add_new_handshake(
@@ -79,5 +135,5 @@ mod tests {
             "putain".to_string(),
             SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 1),
         );
-    }
+    }*/
 }