wip messages handling

client-network/src/registration.rs

@@ -1,36 +1,37 @@
 use bytes::Bytes;
 
 use crate::cryptographic_signature::{CryptographicSignature, formatPubKey, sign_message};
+use crate::message_handling::EventType;
+use crate::messages_channels::{Message, MultipleSenders};
 use crate::messages_structure::{HandshakeMessage, UDPMessage};
+use std::collections::HashMap;
+use std::net::SocketAddr;
 use std::net::UdpSocket;
+use std::sync::{Arc, Mutex};
 
 ///
 /// sends the cryptographic signature to the server using a PUT request over the HTTP API.
 ///
-async fn register_with_the_server(
-    crypto_pair: CryptographicSignature,
+pub async fn register_with_the_server(
+    crypto_pair: &Arc<CryptographicSignature>,
+    server_uri: &String,
 ) -> Result<(), reqwest::Error> {
     let client = reqwest::Client::new();
-    let uri = format!(
-        "https://jch.irif.fr:8443/peers/{}/key",
-        crypto_pair.username
-    );
+    let uri = format!("{0}/peers/{1}/key", server_uri, crypto_pair.username);
     let encoded_point = crypto_pair.pub_key.to_encoded_point(false);
     let pubkey_bytes = encoded_point.as_ref().to_vec();
     let pubkey_bytes_minus = pubkey_bytes[1..].to_vec();
     let res = client.put(uri).body(pubkey_bytes_minus).send().await?;
     if res.status().is_success() {
-        println!("Successfully registered with the server.");
+        let str = hex::encode(res.bytes().await?);
+        println!("Successfully registered with the server : {}", str);
     } else {
         eprintln!(
             "Failed to register with the server. Status: {}",
             res.status()
         );
-        let str = hex::encode(res.bytes().await?);
-        eprintln!("erreur : {}", str);
     }
     println!("register ip adresses");
-    register_ip_addresses(crypto_pair);
     Ok(())
 }
 
@@ -57,21 +58,33 @@ async fn get_socket_address(username: String) -> Result<Bytes, reqwest::Error> {
 ///
 /// registers the IP addresses by sending a Hello request to the server.
 ///
-fn register_ip_addresses(crypto_pair: CryptographicSignature) {
-    let socket = UdpSocket::bind("0.0.0.0:0").expect("bind failed");
+pub fn register_ip_addresses(
+    crypto_pair: &CryptographicSignature,
+    server_uri: String,
+    senders: &MultipleSenders,
+    messages_list: &Arc<Mutex<HashMap<i32, EventType>>>,
+) {
     let username_size = crypto_pair.username.len();
     let hello_handshake =
         HandshakeMessage::hello(545, username_size as u16 + 4, crypto_pair.username.clone());
     //HandshakeMessage::display(&hello_handshake);
     let hello_handshake_serialized = hello_handshake.serialize();
-    let message_signed = sign_message(crypto_pair, hello_handshake_serialized.to_vec());
-    socket
-        .send_to(&message_signed, "81.194.30.229:8443")
-        .expect("send failed");
-    let mut buf = [0u8; 1024];
+    let message_signed = sign_message(crypto_pair, &hello_handshake_serialized);
+    senders.send_via(0, message_signed, server_uri);
+    let mut list = messages_list.lock().expect("Failed to lock messages_list");
+    match list.get(&545) {
+        Some(_) => {
+            list.remove(&545);
+        }
+        None => {
+            list.insert(545, EventType::ServerHelloReply);
+        }
+    }
+    // 3. Perform the insertion
+    /*let mut buf = [0u8; 1024];
     socket.recv_from(&mut buf).expect("receive failed");
     let hello_handshake_received = UDPMessage::parse(buf.to_vec());
-    hello_handshake_received.display();
+    hello_handshake_received.display();*/
 }
 
 #[cfg(test)]
@@ -79,19 +92,20 @@ mod tests {
     // Note this useful idiom: importing names from outer (for mod tests) scope.
     use super::*;
 
-    ///
+    /*///
     /// does the procedure to register with the server
     ///
     #[tokio::test]
     async fn registering_with_server() {
-        let username = String::from("gamixtreize");
+        let username = String::from("gameixtreize");
+        let server_uri = String::from("https://jch.irif.fr:8443");
         let crypto_pair = CryptographicSignature::new(username);
-        if let Err(e) = register_with_the_server(crypto_pair).await {
+        if let Err(e) = register_with_the_server(crypto_pair, server_uri).await {
             eprintln!("Error during registration: {}", e);
         }
-    }
+    }*/
 
-    ///
+    /*///
     /// retreives the socket address of a given peer
     ///
     #[tokio::test]
@@ -105,5 +119,5 @@ mod tests {
                 eprintln!("Erreur HTTP: {}", e);
             }
         }
-    }
+    }*/
 }