registration put

client-gui/src/gui_app.rs

@@ -5,7 +5,7 @@ use client_network::{
 use crossbeam_channel::{Receiver, Sender};
 use egui::{
     Align, Align2, Button, CentralPanel, CollapsingHeader, Context, Id, LayerId, Layout, Order,
-    Popup, ScrollArea, SidePanel, TopBottomPanel, Ui, ViewportCommand,
+    Popup, ScrollArea, SidePanel, TextStyle, TopBottomPanel, Ui, ViewportCommand,
 };
 use std::collections::HashMap;
 
@@ -13,10 +13,14 @@ enum ServerStatus {
     Loading,
     NotConnected,
     Connected,
+    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>,
@@ -25,7 +29,8 @@ pub struct P2PClientApp {
     status_message: String,
     known_peers: Vec<String>,
     connect_address_input: String,
-    connect_server_name_input: String,
+    connected_address: String,
+    connect_name_input: String,
 
     // Key: Parent Directory Hash (String), Value: List of children FileNode
     loaded_fs: HashMap<String, MerkleTree>,
@@ -34,6 +39,10 @@ pub struct P2PClientApp {
     active_peer: Option<String>,
 
     server_status: ServerStatus,
+
+    show_network_popup: bool, // gérer selon besoin
+
+    error_message: Option<String>, // Some(message) -> afficher, None -> rien
 }
 
 impl P2PClientApp {
@@ -45,23 +54,52 @@ impl P2PClientApp {
         loaded_fs.insert("bob".to_string(), tree);
 
         Self {
+            remaining: std::time::Duration::from_secs(0),
+            timer_started: false,
+            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!["bob".to_string()],
             connect_address_input: "https://jch.irif.fr:8443".to_string(),
-            connect_server_name_input: "jch.irif.fr".to_string(),
+            connected_address: "".to_string(),
             loaded_fs,
             active_peer: None,
-            server_status: ServerStatus::Loading,
+            server_status: ServerStatus::NotConnected,
+            show_network_popup: false,
+            error_message: None,
+            connect_name_input: "bob".to_string(),
         }
     }
+    pub fn show_error(&mut self, msg: impl Into<String>) {
+        self.error_message = Some(msg.into());
+    }
+    pub fn clear_error(&mut self) {
+        self.error_message = None;
+    }
 }
 
 // --- 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 {
+            self.remaining = std::time::Duration::from_secs(30 * 60);
+            self.last_update = std::time::Instant::now();
+            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;
+
+        if matches!(self.server_status, ServerStatus::Connected)
+            && self.remaining > std::time::Duration::ZERO
+        {
+            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() {
@@ -75,7 +113,7 @@ impl eframe::App for P2PClientApp {
                     }
                 }
                 NetworkEvent::PeerListUpdated(peers) => {
-                    todo!();
+                    //todo!();
 
                     self.known_peers = peers;
                 }
@@ -100,11 +138,24 @@ impl eframe::App for P2PClientApp {
                     //     root_hash,
                     // ));
                 }
-                NetworkEvent::Connected() => {
+                NetworkEvent::Connected(ip) => {
                     self.server_status = ServerStatus::Connected;
+                    self.connected_address = ip.clone();
+                    let _ = self.network_cmd_tx.send(NetworkCommand::FetchPeerList(
+                        self.connected_address.clone(),
+                    ));
+                }
+                NetworkEvent::ConnectedHandshake() => {
+                    self.server_status = ServerStatus::ConnectedHandshake;
+                }
+                NetworkEvent::Disconnected() => {
+                    self.connected_address = "".to_string();
+                    self.known_peers.clear();
+                    self.server_status = ServerStatus::NotConnected;
+                }
+                NetworkEvent::Error(err) => {
+                    self.show_error(err);
                 }
-                NetworkEvent::Disconnected() => todo!(),
-                NetworkEvent::Error() => todo!(),
                 NetworkEvent::DataReceived(_, merkle_node) => todo!(),
             }
         }
@@ -124,9 +175,49 @@ impl eframe::App for P2PClientApp {
                 });
 
                 ui.menu_button("Network", |ui| {
-                    ui.horizontal(|ui| {
+                    match self.server_status {
-                        ui.label("Server IP:");
+                        ServerStatus::Connected | ServerStatus::ConnectedHandshake => {
-                        ui.text_edit_singleline(&mut self.connect_address_input);
+                            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();
+                                }
+                            });
+                        }
+                        _ => {}
+                    }
+
+                    /* ui.horizontal(|ui| {
+                        ui.label("Server peer name:");
                         ui.text_edit_singleline(&mut self.connect_server_name_input);
                         if ui.button("Connect").clicked() {
                             let addr = self.connect_address_input.clone();
@@ -137,8 +228,51 @@ impl eframe::App for P2PClientApp {
                             self.server_status = ServerStatus::Loading;
                             ui.close();
                         }
-                    });
+                    });*/
                 });
+
+                // état
+
+                /*if ui.button("Network").clicked() {
+                    self.show_network_popup = true;
+                }*/
+
+                /*if self.show_network_popup {
+                    egui::Window::new("Network")
+                        .collapsible(false)
+                        .resizable(false)
+                        .show(ctx, |ui| {
+                            ui.horizontal_wrapped(|ui| {
+                                ui.with_layout(
+                                    egui::Layout::right_to_left(egui::Align::TOP),
+                                    |ui| {
+                                        if ui.button("✕").clicked() {
+                                            self.show_network_popup = false;
+                                        }
+                                    },
+                                );
+                            });
+                            ui.horizontal(|ui| {
+                                ui.label("Server IP:");
+                                ui.text_edit_singleline(&mut self.connect_address_input);
+                            });
+                            ui.horizontal(|ui| {
+                                ui.label("Server peer name:");
+                                ui.text_edit_singleline(&mut self.connect_server_name_input);
+                                if ui.button("Connect").clicked() {
+                                    // envoyer commande...
+                                    let addr = self.connect_address_input.clone();
+                                    let serv_name = self.connect_server_name_input.clone();
+                                    let _ = self
+                                        .network_cmd_tx
+                                        .send(NetworkCommand::ConnectToServer(addr, serv_name));
+                                    self.server_status = ServerStatus::Loading;
+
+                                    self.show_network_popup = false;
+                                }
+                            });
+                        });
+                }*/
             });
         });
 
@@ -149,14 +283,21 @@ impl eframe::App for P2PClientApp {
                         ui.spinner();
                     }
                     ServerStatus::Connected => {
-                        ui.label("📡");
+                        ui.label("Registered but no server peer chosen...");
                     }
                     ServerStatus::NotConnected => {
                         ui.label("No connection..");
                     }
+                    ServerStatus::ConnectedHandshake => {
+                        ui.label("📡");
+                    }
                 }
                 ui.add_space(ui.available_width() - 30.0);
-                ui.label("30:00");
+                // formater mm:ss
+                let secs = self.remaining.as_secs();
+                let minutes = secs / 60;
+                let seconds = secs % 60;
+                ui.label(format!("{:02}:{:02}", minutes, seconds));
             });
         });
 
@@ -168,8 +309,9 @@ impl eframe::App for P2PClientApp {
                     ui.heading("🌐 Known Peers");
                     ui.add_space(20.0);
                     if ui.button("🔄").clicked() {
+                        println!("addr:{}", self.connected_address.clone());
                         let res = self.network_cmd_tx.send(NetworkCommand::FetchPeerList(
-                            self.connect_address_input.clone(),
+                            self.connected_address.clone(),
                         ));
                         if let Some(error) = res.err() {
                             println!(
@@ -189,11 +331,8 @@ impl eframe::App for P2PClientApp {
                         for peer in &self.known_peers {
                             let is_active =
                                 self.active_peer.as_ref().map_or(false, |id| id == peer); // if peer.id == self.active_peer_id
-
+                            let selectable = ui.selectable_label(is_active, format!("{}", peer));
-                            if ui
+                            if selectable.clicked() {
-                                .selectable_label(is_active, format!("{}", peer))
-                                .clicked()
-                            {
                                 // switch to displaying this peer's tree
                                 self.active_peer = Some(peer.clone());
                                 // Request root content if not loaded
@@ -208,6 +347,23 @@ impl eframe::App for P2PClientApp {
                                     // ));
                                 }
                             }
+                            selectable.context_menu(|ui| {
+                                // ... action
+                                match self.server_status {
+                                    ServerStatus::Connected => {}
+                                    _ => {
+                                        if ui
+                                            .button("Utiliser le peer en tant que serveur")
+                                            .clicked()
+                                        {}
+                                    }
+                                }
+                                if ui.button("Infos").clicked() {
+                                    // action 3
+                                    ui.close();
+                                }
+                                // ... autres boutons
+                            });
                         }
                     }
                 });
@@ -242,6 +398,21 @@ impl eframe::App for P2PClientApp {
             // ui.label(format!("Status: {}", self.status_message));
         });
 
+        if let Some(msg) = &self.error_message {
+            let msg = msg.clone();
+            egui::Window::new("Error")
+                .collapsible(false)
+                .resizable(false)
+                .anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
+                .show(ctx, |ui| {
+                    ui.label(&msg);
+                    if ui.button("OK").clicked() {
+                        self.clear_error();
+                    }
+                });
+            ctx.request_repaint();
+        }
+
         ctx.request_repaint_after(std::time::Duration::from_millis(10));
     }
 }

client-gui/src/main.rs

@@ -1,5 +1,5 @@
 use crate::gui_app::P2PClientApp;
-use client_network::{NetworkCommand, NetworkEvent, start_p2p_executor};
+use client_network::{NetworkCommand, NetworkEvent, P2PSharedData, start_p2p_executor};
 
 mod gui_app;
 
@@ -11,7 +11,10 @@ async fn main() -> eframe::Result<()> {
 
     // 2. Start the P2P Network Executor in a separate Tokio task
     // The executor runs in the background of our main async runtime.
-    let _network_handle = start_p2p_executor(network_cmd_rx, network_event_tx);
+
+    let shared_data: Option<P2PSharedData> = None;
+
+    let _network_handle = start_p2p_executor(network_cmd_rx, network_event_tx, shared_data);
 
     // 3. Configure and Run the Eframe/Egui GUI
     let options = eframe::NativeOptions {

client-network/src/lib.rs

@@ -4,6 +4,7 @@ mod message_handling;
 mod messages_channels;
 mod messages_structure;
 mod registration;
+mod server_communication;
 
 use crate::{
     cryptographic_signature::CryptographicSignature,
@@ -12,31 +13,76 @@ use crate::{
     registration::{
         get_socket_address, parse_addresses, register_ip_addresses, register_with_the_server,
     },
+    server_communication::get_peer_list,
 };
 use std::sync::{Arc, Mutex};
 use std::{
+    io::Error,
     net::{SocketAddr, UdpSocket},
     str::FromStr,
 };
 
+pub struct P2PSharedData {
+    shared_socket: Arc<UdpSocket>,
+    shared_cryptopair: Arc<CryptographicSignature>,
+    shared_messageslist: Arc<Mutex<HashMap<i32, EventType>>>,
+    shared_senders: Arc<MultipleSenders>,
+}
+
+impl P2PSharedData {
+    pub fn new(username: String) -> Result<P2PSharedData, Error> {
+        let messages_list = HashMap::<i32, EventType>::new();
+        let username = String::from(username);
+        let crypto_pair = CryptographicSignature::new(username);
+        let socket = UdpSocket::bind("0.0.0.0:0")?;
+        let shared_socket = Arc::new(socket);
+        let shared_cryptopair = Arc::new(crypto_pair);
+        let shared_messageslist = Arc::new(Mutex::new(messages_list));
+
+        let senders = MultipleSenders::new(1, &shared_socket);
+        let shared_senders = Arc::new(senders);
+        Ok(P2PSharedData {
+            shared_socket: shared_socket,
+            shared_cryptopair: shared_cryptopair,
+            shared_messageslist: shared_messageslist,
+            shared_senders: shared_senders,
+        })
+    }
+    pub fn socket(&self) -> Arc<UdpSocket> {
+        self.shared_socket.clone()
+    }
+
+    pub fn cryptopair(&self) -> Arc<CryptographicSignature> {
+        self.shared_cryptopair.clone()
+    }
+
+    pub fn add_message(&self, id: i32, evt: EventType) {
+        let mut map = self.shared_messageslist.lock().unwrap();
+        map.insert(id, evt);
+    }
+}
+
 /// Messages sent to the Network thread by the GUI.
 pub enum NetworkCommand {
-    ConnectToServer(String, String), // ServerIP
+    ConnectToServerPut(String, String), // ServerIP
-    FetchPeerList(String),           // ServerIP
+    ServerHandshake(String),            // ServerName
+    FetchPeerList(String),              // ServerIP
     RegisterAsPeer(String),
     Ping(),
     ConnectPeer(String),     // IP:PORT
     RequestFileTree(String), // peer_id
     RequestDirectoryContent(String, String),
     RequestChunk(String, String),
+    Disconnect(),
     // ...
 }
 
 /// Messages sent to the GUI by the Network thread.
 pub enum NetworkEvent {
-    Connected(),
+    Connected(String),
+    ConnectedHandshake(),
     Disconnected(),
-    Error(),
+    Error(String),
     PeerConnected(String),
     PeerListUpdated(Vec<String>),
     FileTreeReceived(String, Vec<MerkleNode>), // peer_id, content
@@ -69,6 +115,7 @@ pub fn calculate_chunk_id(data: &[u8]) -> String {
 pub fn start_p2p_executor(
     cmd_rx: Receiver<NetworkCommand>,
     event_tx: Sender<NetworkEvent>,
+    mut shared_data: Option<P2PSharedData>,
 ) -> tokio::task::JoinHandle<()> {
     // Use tokio to spawn the asynchronous networking logic
     tokio::task::spawn(async move {
@@ -81,6 +128,51 @@ pub fn start_p2p_executor(
             // Check for commands from the GUI
             if let Ok(cmd) = cmd_rx.try_recv() {
                 match cmd {
+                    NetworkCommand::ServerHandshake(username) => {
+                        let server_addr_query = get_socket_address(username);
+
+                        match server_addr_query.await {
+                            Ok(sockaddr_bytes) => {
+                                match String::from_utf8(sockaddr_bytes.to_vec()) {
+                                    Ok(s) => {
+                                        let addresses = parse_addresses(&s);
+                                        if let Some(first) = addresses.first() {
+                                            // first: &SocketAddr
+                                            /*start_receving_thread(
+                                                &shared_socket,
+                                                &shared_messageslist,
+                                                &shared_cryptopair,
+                                                *first, // copie le SocketAddr (implémente Copy pour SocketAddr)
+                                                &shared_senders,
+                                            );
+                                            register_ip_addresses(
+                                                &shared_cryptopair,
+                                                first.to_string(),
+                                                &shared_senders,
+                                                &shared_messageslist,
+                                                545,
+                                            );*/
+
+                                            //let res = event_tx.send(NetworkEvent::Connected());
+                                        } else {
+                                            //let res = event_tx.send(NetworkEvent::Error());
+                                            eprintln!("no valid socket addresses found in: {}", s);
+                                        }
+                                    }
+                                    Err(e) => {
+                                        //let res = event_tx.send(NetworkEvent::Error());
+                                        eprintln!("invalid UTF-8 in socket address bytes: {}", e);
+                                    }
+                                }
+                            }
+                            Err(e) => {
+                                let mut err_msg =
+                                    String::from("failed to retrieve socket address:");
+                                err_msg += &e.to_string();
+                                let res = event_tx.send(NetworkEvent::Error(err_msg));
+                            }
+                        }
+                    }
                     NetworkCommand::ConnectPeer(addr) => {
                         println!("[Network] ConnectPeer() called");
                         println!("[Network] Attempting to connect to: {}", addr);
@@ -97,78 +189,75 @@ pub fn start_p2p_executor(
                     NetworkCommand::RequestChunk(_, _) => {
                         println!("[Network] RequestChunk() called");
                     }
-                    NetworkCommand::ConnectToServer(ip, server_name) => {
+                    NetworkCommand::ConnectToServerPut(ip, name) => {
                         println!("[Network] ConnectToServer() called");
 
                         // Actual server connection
 
-                        let messages_list = HashMap::<i32, EventType>::new();
+                        shared_data = match P2PSharedData::new(name.clone()) {
-
+                            Ok(sd) => Some(sd),
-                        let username = String::from("az");
+                            Err(e) => {
-
+                                let mut err_msg = String::from("failed to initialize socket: ");
-                        let crypto_pair = CryptographicSignature::new(username);
+                                err_msg += &e.to_string();
-
+                                let res = event_tx.send(NetworkEvent::Error(err_msg));
-                        let socket = UdpSocket::bind("0.0.0.0:0").expect("bind failed");
+                                let res = event_tx.send(NetworkEvent::Disconnected());
-
+                                None
-                        let shared_socket = Arc::new(socket);
-                        let shared_cryptopair = Arc::new(crypto_pair);
-                        let shared_messageslist = Arc::new(Mutex::new(messages_list));
-
-                        let senders = MultipleSenders::new(1, &shared_socket);
-
-                        let shared_senders = Arc::new(senders);
-                        if let Err(e) = register_with_the_server(&shared_cryptopair, &ip).await {
-                            eprintln!("request failed: {}", e);
-                        }
-
-                        println!("ip: {}", ip);
-
-                        let server_addr_query = get_socket_address(server_name);
-
-                        match server_addr_query.await {
-                            Ok(sockaddr_bytes) => {
-                                match String::from_utf8(sockaddr_bytes.to_vec()) {
-                                    Ok(s) => {
-                                        let addresses = parse_addresses(&s);
-                                        if let Some(first) = addresses.first() {
-                                            // first: &SocketAddr
-                                            start_receving_thread(
-                                                &shared_socket,
-                                                &shared_messageslist,
-                                                &shared_cryptopair,
-                                                *first, // copie le SocketAddr (implémente Copy pour SocketAddr)
-                                                &shared_senders,
-                                            );
-                                            register_ip_addresses(
-                                                &shared_cryptopair,
-                                                first.to_string(),
-                                                &shared_senders,
-                                                &shared_messageslist,
-                                                545,
-                                            );
-                                        } else {
-                                            eprintln!("no valid socket addresses found in: {}", s);
-                                        }
-                                    }
-                                    Err(e) => {
-                                        eprintln!("invalid UTF-8 in socket address bytes: {}", e);
-                                    }
-                                }
                             }
-                            Err(e) => eprintln!("failed to retrieve socket address: {}", e),
+                        };
+
+                        if let Some(sd) = shared_data.as_ref() {
+                            if let Err(e) = register_with_the_server(&sd.cryptopair(), &ip).await {
+                                let mut err_msg = String::from("request failed: ");
+                                err_msg += &e.to_string();
+                                let res = event_tx.send(NetworkEvent::Error(err_msg));
+                                let res = event_tx.send(NetworkEvent::Disconnected());
+                            } else {
+                                let res = event_tx.send(NetworkEvent::Connected(ip));
+                                println!("username created: {}", sd.cryptopair().username);
+                            }
+                            //println!("ip: {}", ip);
                         }
 
-                        tokio::time::sleep(std::time::Duration::from_millis(5000)).await;
+                        //tokio::time::sleep(std::time::Duration::from_millis(5000)).await;
 
-                        let res = event_tx.send(NetworkEvent::Connected());
+                        /*let res = event_tx.send(NetworkEvent::Connected());
                         if let Some(error) = res.err() {
                             println!(
                                 "[Network] Couldn't send crossbeam message to GUI: {}",
                                 error.to_string()
                             );
-                        }
+                        }*/
                     }
                     NetworkCommand::FetchPeerList(ip) => {
+                        if ip == "" {
+                            let res = event_tx.send(NetworkEvent::Error(
+                                "Not registered to any server".to_string(),
+                            ));
+                        } else {
+                            println!("cc");
+                            match get_peer_list(ip).await {
+                                Ok(body) => match String::from_utf8(body.to_vec()) {
+                                    Ok(peers_list) => {
+                                        let mut peers: Vec<String> = Vec::new();
+                                        let mut current = String::new();
+                                        for i in peers_list.chars() {
+                                            if i == '\n' {
+                                                peers.push(current.clone());
+                                                current.clear();
+                                            } else {
+                                                current.push(i);
+                                            }
+                                        }
+                                        let res =
+                                            event_tx.send(NetworkEvent::PeerListUpdated(peers));
+                                    }
+                                    Err(e) => {
+                                        eprintln!("invalid UTF-8 in socket address bytes: {}", e);
+                                    }
+                                },
+                                Err(e) => println!("error"),
+                            }
+                        }
                         println!("[Network] FetchPeerList() called");
                     }
                     NetworkCommand::RegisterAsPeer(_) => {
@@ -177,6 +266,15 @@ pub fn start_p2p_executor(
                     NetworkCommand::Ping() => {
                         println!("[Network] Ping() called");
                     }
+                    NetworkCommand::Disconnect() => {
+                        if let Some(sd) = shared_data.as_ref() {
+                            println!("Disconnecting: {}", &sd.cryptopair().username);
+                            shared_data = None;
+                            let res = event_tx.send(NetworkEvent::Disconnected());
+                        } else {
+                            println!("no p2p data");
+                        }
+                    }
                 }
             }
 

client-network/src/registration.rs

@@ -1,4 +1,5 @@
 use bytes::Bytes;
+use getrandom::Error;
 
 use crate::cryptographic_signature::{CryptographicSignature, formatPubKey, sign_message};
 use crate::message_handling::EventType;
@@ -23,15 +24,7 @@ pub async fn register_with_the_server(
     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() {
+    let res = res.error_for_status()?;
-        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()
-        );
-    }
     println!("register ip adresses");
     Ok(())
 }

client-network/src/server_communication.rs

@@ -0,0 +1,17 @@
+use bytes::Bytes;
+
+pub async fn get_peer_list(server_address: String) -> Result<Bytes, reqwest::Error> {
+    let client = reqwest::Client::new();
+    let uri = format!("{}/peers/", server_address);
+    let res = client.get(uri).send().await?;
+    if res.status().is_success() {
+        println!("Successfully retreived the addresses.");
+    } else {
+        eprintln!(
+            "Failed to get the peers addresses from the server. Status: {}",
+            res.status()
+        );
+    }
+    let body: Bytes = res.bytes().await?;
+    Ok(body)
+}