From 3864aeadb4c52d4487d4eb7ad264727aa413b5ce Mon Sep 17 00:00:00 2001 From: AndreaDenina Date: Sat, 1 Feb 2025 18:25:05 +0100 Subject: [PATCH 1/5] sending events to simcontroller, i need to modify the Events --- src/chat_client.rs | 38 ++++++++++++++++++++++++++++---------- 1 file changed, 28 insertions(+), 10 deletions(-) diff --git a/src/chat_client.rs b/src/chat_client.rs index 8388221..0c3ec36 100644 --- a/src/chat_client.rs +++ b/src/chat_client.rs @@ -4,10 +4,7 @@ use colored::Colorize; use crossbeam_channel::{select_biased, Receiver, Sender}; use log::{error, info, warn}; -use messages::{ - client_commands::*, - high_level_messages::{Message, MessageContent}, -}; +use messages::{client_commands::*, high_level_messages::*}; use rand::Rng; use std::collections::{HashMap, HashSet}; @@ -727,7 +724,6 @@ impl ChatClient { } // the sim controller could send a command to the client that makes it start the flooding - fn start_flooding(&mut self) { let flood_request = FloodRequest { @@ -1075,8 +1071,8 @@ impl ChatClient { } if let MessageContent::FromServer(server_message) = message.content { match server_message { - messages::ServerMessage::ClientList(items) => { - self.client_list = items; + ServerMessage::ClientList(client_list) => { + self.client_list = client_list; info!( "{} [ ChatClient {} ]: Updated client list: {:?}", @@ -1084,8 +1080,13 @@ impl ChatClient { self.id, self.client_list ); + + self.controller_send.send(ChatClientEvent::ClientList( + message.source_id, + self.client_list.clone(), + )); } - messages::ServerMessage::MessageReceived { sender_id, content } => { + ServerMessage::MessageReceived { sender_id, content } => { info!( "{} [ ChatClient {} ]: Message received from [ Client {} ]: {}", "✓".green(), @@ -1093,14 +1094,30 @@ impl ChatClient { sender_id, content ); + + self.controller_send + .send(ChatClientEvent::MessageReceived(sender_id, content)); } - messages::ServerMessage::ErrorWrongClientId => { + ServerMessage::ErrorWrongClientId => { + // devo definire errori tra gli eventi error!( "{} [ ChatClient {} ]: Received an error indicating wrong client ID", "✗".red(), self.id ); } + ServerMessage::SuccessfulRegistration => { + self.registered = Some(message.source_id); + info!( + "{} [ ChatClient {} ]: Successfully registered to the server [ CommunicationServer {} ]", + "✓".green(), + self.id, + message.source_id + ); + self.controller_send + .send(ChatClientEvent::RegisteredToServer(message.source_id)) + .unwrap(); + } _ => { error!( "{} [ ChatClient {} ]: Received a message intended for a web browser", @@ -1109,9 +1126,10 @@ impl ChatClient { ); } } + } else { + // errore un client non può comunicare direttamente con un altro client } } else { - //log that there are no messages to read info!( "{} [ ChatClient {} ]: No messages to read", "ℹ".blue(), From cbbaf17991427f90b243332b2f02930900985901 Mon Sep 17 00:00:00 2001 From: AndreaDenina Date: Sat, 1 Feb 2025 19:20:36 +0100 Subject: [PATCH 2/5] events --- Cargo.lock | 2 +- src/chat_client.rs | 163 +++++++++++++++++++++++++++++++++++---------- 2 files changed, 129 insertions(+), 36 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index dda5b5f..b6ce054 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -124,7 +124,7 @@ checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" [[package]] name = "messages" version = "0.1.0" -source = "git+https://github.com/Rustastic/Messages.git#1a8c9feb6133fc3434e73c2fbfdb09e1732ae6c0" +source = "git+https://github.com/Rustastic/Messages.git#7ca00c8b6eb36879aa1b3d6b700609b8d753174d" dependencies = [ "bincode", "crossbeam-channel", diff --git a/src/chat_client.rs b/src/chat_client.rs index 0c3ec36..12cae8b 100644 --- a/src/chat_client.rs +++ b/src/chat_client.rs @@ -16,6 +16,13 @@ use wg_2024::{ }, }; + +todo!("handling errori nell'invio di messaggi"); +todo!("refactoring handling messaggi"); +todo!("handle server type nella read message"); + + + pub struct ChatClient { id: NodeId, running: bool, @@ -145,13 +152,32 @@ impl ChatClient { let session_id = self.session_id_counter; self.session_id_counter += 1; - let message = - Message::new_client_message(session_id, self.id, destination_id, text); + if let Some(server_id) = self.registered { + let message = Message::new_client_message( + session_id, + self.id, + server_id, + ClientMessage::SendMessage { + recipient_id: destination_id, + content: text, + }, + ); - self.send_message_to(message); + self.send_message_to(message); + } else { + error!( + "{} [ ChatClient {} ]: Cannot send message, not registered to any server", + "✗".red(), + self.id + ); + self.controller_send + .send(ChatClientEvent::ErrorNotRegistered) + .unwrap(); + } } ChatClientCommand::RegisterTo(server_id) => self.register_to(server_id), - ChatClientCommand::GetClientListFrom(_) => self.get_client_list(), + ChatClientCommand::GetClientList => self.get_client_list(), + ChatClientCommand::LogOut => self.logout(), } } @@ -1056,7 +1082,6 @@ impl ChatClient { } } - todo!("MODIFICARE QUESTO METODO E FARE IN MODO CHE COMUNICHI CON IL SIM CONTROLLER"); fn read_message(&mut self) { if let Some(message) = self.message_buffer.pop() { if message.destination_id != self.id { @@ -1081,10 +1106,9 @@ impl ChatClient { self.client_list ); - self.controller_send.send(ChatClientEvent::ClientList( - message.source_id, - self.client_list.clone(), - )); + self.controller_send + .send(ChatClientEvent::ClientList(self.client_list.clone())) + .unwrap(); } ServerMessage::MessageReceived { sender_id, content } => { info!( @@ -1096,15 +1120,22 @@ impl ChatClient { ); self.controller_send - .send(ChatClientEvent::MessageReceived(sender_id, content)); + .send(ChatClientEvent::MessageReceived(sender_id, content)) + .unwrap(); } - ServerMessage::ErrorWrongClientId => { - // devo definire errori tra gli eventi - error!( - "{} [ ChatClient {} ]: Received an error indicating wrong client ID", - "✗".red(), - self.id + ServerMessage::UnreachableClient(client_id) => { + info!( + "{} [ ChatClient {} ]: Client {} is unreachable", + "!!!".yellow(), + self.id, + client_id ); + + self.client_list.retain(|&id| id != client_id); + + self.controller_send + .send(ChatClientEvent::Unreachable(client_id)) + .unwrap(); } ServerMessage::SuccessfulRegistration => { self.registered = Some(message.source_id); @@ -1115,7 +1146,19 @@ impl ChatClient { message.source_id ); self.controller_send - .send(ChatClientEvent::RegisteredToServer(message.source_id)) + .send(ChatClientEvent::SuccessfulRegistration(message.source_id)) + .unwrap(); + } + ServerMessage::SuccessfullLogOut => { + self.registered = None; + info!( + "{} [ ChatClient {} ]: Successfully logged out from the server [ CommunicationServer {} ]", + "✓".green(), + self.id, + message.source_id + ); + self.controller_send + .send(ChatClientEvent::SuccessfulLogOut) .unwrap(); } _ => { @@ -1128,6 +1171,12 @@ impl ChatClient { } } else { // errore un client non può comunicare direttamente con un altro client + error!( + "{} [ ChatClient {} ]: Received a message from an unexpected source: [ Client {} ]", + "✗".red(), + self.id, + message.source_id + ); } } else { info!( @@ -1140,19 +1189,19 @@ impl ChatClient { todo!("gestire i casi di errore"); fn send_message_to(&self, message: Message) { // controllo che il chat client conosca i server, che sia registrato ad uno di loro e che la destinazione sia registrata a quel server - if self.running - && let Some(server_id) = self.registered - { + if self.running { self.get_client_list(); if self.client_list.contains(&message.source_id) { - if let Ok(fragments) = self.assembler.fragment_message(&message) { - let path = self.network_knowledge.find_paths_to(self.id, server_id)[0]; + let path = self + .network_knowledge + .find_paths_to(self.id, message.destination_id)[0]; - let routing_header = SourceRoutingHeader { - hop_index: 0, - hops: path.clone(), - }; + let routing_header = SourceRoutingHeader { + hop_index: 1, + hops: path.clone(), + }; + if let Ok(fragments) = self.assembler.fragment_message(&message) { for frag in fragments { let packet_to_send = Packet { routing_header: routing_header.clone(), @@ -1163,18 +1212,22 @@ impl ChatClient { self.packet_cache.insert(packet_to_send.clone()); info!( - "{} [ ChatClient {} ]: Sending fragment with session_id: {} and fragment_index: {} to [ Server {} ]", + "{} [ ChatClient {} ]: Sending fragment with session_id: {} and fragment_index: {} to [ CommunicationServer {} ]", "✓".green(), self.id, message.session_id, frag.fragment_index, - server_id + message.destination_id ); self.forward_packet(packet_to_send); } } + } else { + // unreachable } + } else { + //error not runnig } } @@ -1187,13 +1240,13 @@ impl ChatClient { session_id, self.id, server_id, - messages::high_level_messages::ClientMessage::GetServerType, + ClientMessage::GetServerType, ); let path = self.network_knowledge.find_paths_to(self.id, server_id)[0]; let routing_header = SourceRoutingHeader { - hop_index: 0, + hop_index: 1, hops: path, }; @@ -1232,13 +1285,13 @@ impl ChatClient { session_id, self.id, server_id, - messages::high_level_messages::ClientMessage::GetClientList, + ClientMessage::GetClientList, ); let path = self.network_knowledge.find_paths_to(self.id, server_id)[0]; let routing_header = SourceRoutingHeader { - hop_index: 0, + hop_index: 1, hops: path, }; @@ -1274,13 +1327,13 @@ impl ChatClient { session_id, self.id, server_id, - messages::high_level_messages::ClientMessage::RegisterToChat, + ClientMessage::RegisterToChat, ); let path = self.network_knowledge.find_paths_to(self.id, server_id)[0]; let routing_header = SourceRoutingHeader { - hop_index: 0, + hop_index: 1, hops: path, }; @@ -1295,7 +1348,7 @@ impl ChatClient { self.packet_cache.insert(packet.clone()); info!( - "{} [ ChatClient {} ]: Registering to [ Server {} ] with session_id: {}", + "{} [ ChatClient {} ]: Registering to [ CommunicationServer {} ] with session_id: {}", "ℹ".blue(), self.id, server_id, @@ -1307,4 +1360,44 @@ impl ChatClient { } } } + + fn logout(&mut self) { + if self.running { + let session_id = self.session_id_counter; + self.session_id_counter += 1; + let message = + Message::new_client_message(session_id, self.id, server_id, ClientMessage::Logout); + + let path = self.network_knowledge.find_paths_to(self.id, server_id)[0]; + + let routing_header = SourceRoutingHeader { + hop_index: 1, + hops: path, + }; + + if let Ok(fragments) = self.assembler.fragment_message(&message) { + for frag in fragments { + let packet = Packet { + routing_header: routing_header.clone(), + session_id, + pack_type: PacketType::MsgFragment(frag), + }; + + self.packet_cache.insert(packet.clone()); + + info!( + "{} [ ChatClient {} ]: Logging out from [ CommunicationServer {} ] with session_id: {}", + "ℹ".blue(), + self.id, + server_id, + session_id + ); + + self.forward_packet(packet); + } + } + } else { + // error not running + } + } } From 0f72c09834d045c8d8e22de6f3e5843b19e3f428 Mon Sep 17 00:00:00 2001 From: AndreaDenina Date: Sun, 2 Feb 2025 01:50:14 +0100 Subject: [PATCH 3/5] handling message ServerType --- src/chat_client.rs | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/src/chat_client.rs b/src/chat_client.rs index 12cae8b..fa5bbd0 100644 --- a/src/chat_client.rs +++ b/src/chat_client.rs @@ -1096,6 +1096,17 @@ impl ChatClient { } if let MessageContent::FromServer(server_message) = message.content { match server_message { + ServerMessage::ServerType(server_type) => { + if let ServerType::Chat = server_type { + self.communication_server_list.push(message.source_id); + info!( + "{} [ ChatClient {} ]: Discovered communication server [ CommunicationServer {} ]", + "✓".green(), + self.id, + message.source_id + ); + } + } ServerMessage::ClientList(client_list) => { self.client_list = client_list; From 597c128b4fd8c60afcef33067b67e636dbdaf7ef Mon Sep 17 00:00:00 2001 From: AndreaDenina Date: Sun, 2 Feb 2025 02:42:58 +0100 Subject: [PATCH 4/5] bug fixing + final feautures added --- Cargo.lock | 4 +- src/chat_client.rs | 340 +++++++++++++++++++++++---------------- src/network_structure.rs | 5 +- src/packet_cache.rs | 4 +- 4 files changed, 209 insertions(+), 144 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index b6ce054..4eed7fa 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -220,9 +220,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.96" +version = "2.0.98" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d5d0adab1ae378d7f53bdebc67a39f1f151407ef230f0ce2883572f5d8985c80" +checksum = "36147f1a48ae0ec2b5b3bc5b537d267457555a10dc06f3dbc8cb11ba3006d3b1" dependencies = [ "proc-macro2", "quote", diff --git a/src/chat_client.rs b/src/chat_client.rs index fa5bbd0..6e8fd6d 100644 --- a/src/chat_client.rs +++ b/src/chat_client.rs @@ -11,18 +11,10 @@ use std::collections::{HashMap, HashSet}; use wg_2024::{ network::{NodeId, SourceRoutingHeader}, packet::{ - self, Ack, FloodRequest, FloodResponse, Fragment, Nack, NackType, NodeType, Packet, - PacketType, + Ack, FloodRequest, FloodResponse, Fragment, Nack, NackType, NodeType, Packet, PacketType, }, }; - -todo!("handling errori nell'invio di messaggi"); -todo!("refactoring handling messaggi"); -todo!("handle server type nella read message"); - - - pub struct ChatClient { id: NodeId, running: bool, @@ -149,35 +141,114 @@ impl ChatClient { self.query_communication_servers(); } ChatClientCommand::SendMessageTo(destination_id, text) => { - let session_id = self.session_id_counter; - self.session_id_counter += 1; - - if let Some(server_id) = self.registered { - let message = Message::new_client_message( - session_id, - self.id, - server_id, - ClientMessage::SendMessage { - recipient_id: destination_id, - content: text, - }, + if self.running { + if let Some(server_id) = self.registered { + let session_id = self.session_id_counter; + self.session_id_counter += 1; + let message = Message::new_client_message( + session_id, + self.id, + server_id, + ClientMessage::SendMessage { + recipient_id: destination_id, + content: text, + }, + ); + self.send_message_to(message, destination_id); + } else { + error!( + "{} [ ChatClient {} ]: Cannot send message, not registered to any server", + "✗".red(), + self.id + ); + self.controller_send + .send(ChatClientEvent::ErrorNotRegistered) + .unwrap(); + } + } else { + error!( + "{} [ ChatClient {} ]: Cannot send message, ChatClient is not running", + "✗".red(), + self.id ); - - self.send_message_to(message); + self.controller_send + .send(ChatClientEvent::ErrorNotRunning) + .unwrap(); + } + } + ChatClientCommand::RegisterTo(server_id) => { + if self.running { + if self.communication_server_list.contains(&server_id) { + self.register_to(server_id) + } else { + error!( + "{} [ ChatClient {} ]: Cannot register to server {}, it is not a communication server", + "✗".red(), + self.id, + server_id + ); + } + } else { + error!( + "{} [ ChatClient {} ]: Cannot send message, ChatClient is not running", + "✗".red(), + self.id + ); + self.controller_send + .send(ChatClientEvent::ErrorNotRunning) + .unwrap(); + } + } + ChatClientCommand::GetClientList => { + if self.running { + if let Some(_) = self.registered { + self.get_client_list(); + } else { + error!( + "{} [ ChatClient {} ]: Cannot send message, not registered to any server", + "✗".red(), + self.id + ); + self.controller_send + .send(ChatClientEvent::ErrorNotRegistered) + .unwrap(); + } + } else { + error!( + "{} [ ChatClient {} ]: Cannot send message, ChatClient is not running", + "✗".red(), + self.id + ); + self.controller_send + .send(ChatClientEvent::ErrorNotRunning) + .unwrap(); + } + } + ChatClientCommand::LogOut => { + if self.running { + if let Some(_) = self.registered { + self.logout(); + } else { + error!( + "{} [ ChatClient {} ]: Cannot send message, not registered to any server", + "✗".red(), + self.id + ); + self.controller_send + .send(ChatClientEvent::ErrorNotRegistered) + .unwrap(); + } } else { error!( - "{} [ ChatClient {} ]: Cannot send message, not registered to any server", + "{} [ ChatClient {} ]: Cannot send message, ChatClient is not running", "✗".red(), self.id ); self.controller_send - .send(ChatClientEvent::ErrorNotRegistered) + .send(ChatClientEvent::ErrorNotRunning) .unwrap(); } } - ChatClientCommand::RegisterTo(server_id) => self.register_to(server_id), - ChatClientCommand::GetClientList => self.get_client_list(), - ChatClientCommand::LogOut => self.logout(), } } @@ -258,7 +329,7 @@ impl ChatClient { self.packet_send.contains_key(&destination) } - fn handle_fragment(&mut self, mut packet: Packet, fragment: Fragment) { + fn handle_fragment(&mut self, packet: Packet, fragment: Fragment) { // Add the fragment to the buffer info!( "{} [ ChatClient {} ]: forwarded the the fragment [ fragment_index: {} ] of the Packet [ session_id: {} ]", @@ -351,7 +422,7 @@ impl ChatClient { } } - fn handle_ack_nack(&mut self, mut packet: Packet) { + fn handle_ack_nack(&mut self, packet: Packet) { if let PacketType::Nack(nack) = packet.clone().pack_type { warn!( "{} [ ChatClient {} ]: received a {}", @@ -1145,7 +1216,7 @@ impl ChatClient { self.client_list.retain(|&id| id != client_id); self.controller_send - .send(ChatClientEvent::Unreachable(client_id)) + .send(ChatClientEvent::UnreachableClient(client_id)) .unwrap(); } ServerMessage::SuccessfulRegistration => { @@ -1197,32 +1268,31 @@ impl ChatClient { ); } } - todo!("gestire i casi di errore"); - fn send_message_to(&self, message: Message) { - // controllo che il chat client conosca i server, che sia registrato ad uno di loro e che la destinazione sia registrata a quel server - if self.running { - self.get_client_list(); - if self.client_list.contains(&message.source_id) { - let path = self - .network_knowledge - .find_paths_to(self.id, message.destination_id)[0]; - - let routing_header = SourceRoutingHeader { - hop_index: 1, - hops: path.clone(), - }; - if let Ok(fragments) = self.assembler.fragment_message(&message) { - for frag in fragments { - let packet_to_send = Packet { - routing_header: routing_header.clone(), - session_id: message.session_id, - pack_type: PacketType::MsgFragment(frag), - }; + fn send_message_to(&mut self, message: Message, client_destination: NodeId) { + self.get_client_list(); + if self.client_list.contains(&client_destination) { + let path = self + .network_knowledge + .find_paths_to(self.id, message.destination_id)[0] + .clone(); - self.packet_cache.insert(packet_to_send.clone()); + let routing_header = SourceRoutingHeader { + hop_index: 1, + hops: path.clone(), + }; - info!( + if let Ok(fragments) = self.assembler.fragment_message(&message) { + for frag in fragments { + let packet_to_send = Packet { + routing_header: routing_header.clone(), + session_id: message.session_id, + pack_type: PacketType::MsgFragment(frag.clone()), + }; + + self.packet_cache.insert(packet_to_send.clone()); + + info!( "{} [ ChatClient {} ]: Sending fragment with session_id: {} and fragment_index: {} to [ CommunicationServer {} ]", "✓".green(), self.id, @@ -1231,14 +1301,20 @@ impl ChatClient { message.destination_id ); - self.forward_packet(packet_to_send); - } + self.forward_packet(packet_to_send); } - } else { - // unreachable } } else { - //error not runnig + // unreachable + error!( + "{} [ ChatClient {} ]: Cannot send message, destination client {} is unreachable", + "✗".red(), + self.id, + client_destination + ); + self.controller_send + .send(ChatClientEvent::UnreachableClient(client_destination)) + .unwrap(); } } @@ -1250,11 +1326,11 @@ impl ChatClient { let query = Message::new_client_message( session_id, self.id, - server_id, + *server_id, ClientMessage::GetServerType, ); - let path = self.network_knowledge.find_paths_to(self.id, server_id)[0]; + let path = self.network_knowledge.find_paths_to(self.id, *server_id)[0].clone(); let routing_header = SourceRoutingHeader { hop_index: 1, @@ -1286,37 +1362,35 @@ impl ChatClient { } fn get_client_list(&mut self) { - if self.running - && let Some(server_id) = self.registered - { - let session_id = self.session_id_counter; - self.session_id_counter += 1; + let server_id = self.registered.unwrap(); + let session_id = self.session_id_counter; + self.session_id_counter += 1; - let message = Message::new_client_message( - session_id, - self.id, - server_id, - ClientMessage::GetClientList, - ); + let message = Message::new_client_message( + session_id, + self.id, + server_id, + ClientMessage::GetClientList, + ); - let path = self.network_knowledge.find_paths_to(self.id, server_id)[0]; + let path = self.network_knowledge.find_paths_to(self.id, server_id)[0].clone(); - let routing_header = SourceRoutingHeader { - hop_index: 1, - hops: path, - }; + let routing_header = SourceRoutingHeader { + hop_index: 1, + hops: path, + }; - if let Ok(fragments) = self.assembler.fragment_message(&message) { - for frag in fragments { - let packet = Packet { - routing_header: routing_header.clone(), - session_id, - pack_type: PacketType::MsgFragment(frag), - }; + if let Ok(fragments) = self.assembler.fragment_message(&message) { + for frag in fragments { + let packet = Packet { + routing_header: routing_header.clone(), + session_id, + pack_type: PacketType::MsgFragment(frag), + }; - self.packet_cache.insert(packet.clone()); + self.packet_cache.insert(packet.clone()); - info!( + info!( "{} [ ChatClient {} ]: Requesting client list from [ Server {} ] with session_id: {}", "ℹ".blue(), self.id, @@ -1324,41 +1398,39 @@ impl ChatClient { session_id ); - self.forward_packet(packet); - } + self.forward_packet(packet); } } } fn register_to(&mut self, server_id: NodeId) { - if self.running && self.communication_server_list.contains(&server_id) { - let session_id = self.session_id_counter; - self.session_id_counter += 1; - let message = Message::new_client_message( - session_id, - self.id, - server_id, - ClientMessage::RegisterToChat, - ); + let session_id = self.session_id_counter; + self.session_id_counter += 1; + let message = Message::new_client_message( + session_id, + self.id, + server_id, + ClientMessage::RegisterToChat, + ); - let path = self.network_knowledge.find_paths_to(self.id, server_id)[0]; + let path = self.network_knowledge.find_paths_to(self.id, server_id)[0].clone(); - let routing_header = SourceRoutingHeader { - hop_index: 1, - hops: path, - }; + let routing_header = SourceRoutingHeader { + hop_index: 1, + hops: path, + }; - if let Ok(fragments) = self.assembler.fragment_message(&message) { - for frag in fragments { - let packet = Packet { - routing_header: routing_header.clone(), - session_id, - pack_type: PacketType::MsgFragment(frag), - }; + if let Ok(fragments) = self.assembler.fragment_message(&message) { + for frag in fragments { + let packet = Packet { + routing_header: routing_header.clone(), + session_id, + pack_type: PacketType::MsgFragment(frag), + }; - self.packet_cache.insert(packet.clone()); + self.packet_cache.insert(packet.clone()); - info!( + info!( "{} [ ChatClient {} ]: Registering to [ CommunicationServer {} ] with session_id: {}", "ℹ".blue(), self.id, @@ -1366,37 +1438,36 @@ impl ChatClient { session_id ); - self.forward_packet(packet); - } + self.forward_packet(packet); } } } fn logout(&mut self) { - if self.running { - let session_id = self.session_id_counter; - self.session_id_counter += 1; - let message = - Message::new_client_message(session_id, self.id, server_id, ClientMessage::Logout); + let server_id = self.registered.unwrap(); + let session_id = self.session_id_counter; + self.session_id_counter += 1; + let message = + Message::new_client_message(session_id, self.id, server_id, ClientMessage::Logout); - let path = self.network_knowledge.find_paths_to(self.id, server_id)[0]; + let path = self.network_knowledge.find_paths_to(self.id, server_id)[0].clone(); - let routing_header = SourceRoutingHeader { - hop_index: 1, - hops: path, - }; + let routing_header = SourceRoutingHeader { + hop_index: 1, + hops: path, + }; - if let Ok(fragments) = self.assembler.fragment_message(&message) { - for frag in fragments { - let packet = Packet { - routing_header: routing_header.clone(), - session_id, - pack_type: PacketType::MsgFragment(frag), - }; + if let Ok(fragments) = self.assembler.fragment_message(&message) { + for frag in fragments { + let packet = Packet { + routing_header: routing_header.clone(), + session_id, + pack_type: PacketType::MsgFragment(frag), + }; - self.packet_cache.insert(packet.clone()); + self.packet_cache.insert(packet.clone()); - info!( + info!( "{} [ ChatClient {} ]: Logging out from [ CommunicationServer {} ] with session_id: {}", "ℹ".blue(), self.id, @@ -1404,11 +1475,8 @@ impl ChatClient { session_id ); - self.forward_packet(packet); - } + self.forward_packet(packet); } - } else { - // error not running } } } diff --git a/src/network_structure.rs b/src/network_structure.rs index c6ab59b..1a7439a 100644 --- a/src/network_structure.rs +++ b/src/network_structure.rs @@ -1,7 +1,4 @@ -use std::{ - collections::{HashMap, HashSet}, - thread::current, -}; +use std::collections::{HashMap, HashSet}; use wg_2024::{network::NodeId, packet::NodeType}; diff --git a/src/packet_cache.rs b/src/packet_cache.rs index c6cb772..12be2b8 100644 --- a/src/packet_cache.rs +++ b/src/packet_cache.rs @@ -1,8 +1,8 @@ use std::collections::HashMap; use log::error; -use rand::seq::index; -use wg_2024::packet::{Fragment, Packet, PacketType}; + +use wg_2024::packet::{Packet, PacketType}; pub struct PacketCache { // session_id, fragment_id From 6909469022d1bb2fa03d388db532f7b04289a966 Mon Sep 17 00:00:00 2001 From: AndreaDenina Date: Sun, 2 Feb 2025 18:15:04 +0100 Subject: [PATCH 5/5] fixed packet handling --- Cargo.lock | 2 +- src/chat_client.rs | 41 +++++++++++++++-------------------------- 2 files changed, 16 insertions(+), 27 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 4eed7fa..f948c57 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -124,7 +124,7 @@ checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" [[package]] name = "messages" version = "0.1.0" -source = "git+https://github.com/Rustastic/Messages.git#7ca00c8b6eb36879aa1b3d6b700609b8d753174d" +source = "git+https://github.com/Rustastic/Messages.git#08bd4d7d9c72a6696ad3d9ba1a77b3d38307bc85" dependencies = [ "bincode", "crossbeam-channel", diff --git a/src/chat_client.rs b/src/chat_client.rs index 6e8fd6d..1b52e9c 100644 --- a/src/chat_client.rs +++ b/src/chat_client.rs @@ -374,7 +374,7 @@ impl ChatClient { warn!("├─>{} Sending to Simulation Controller...", "!!!".yellow()); self.controller_send - .send(DroneEvent::PacketDropped(packet)) + .send(ChatClientEvent::ControllerShortcut(packet)) .unwrap(); warn!( @@ -407,7 +407,7 @@ impl ChatClient { warn!("├─>{} Sending to Simulation Controller...", "!!!".yellow()); self.controller_send - .send(DroneEvent::PacketDropped(packet)) + .send(ChatClientEvent::ControllerShortcut(packet)) .unwrap(); warn!( @@ -423,24 +423,13 @@ impl ChatClient { } fn handle_ack_nack(&mut self, packet: Packet) { - if let PacketType::Nack(nack) = packet.clone().pack_type { - warn!( - "{} [ ChatClient {} ]: received a {}", - "!!!".yellow(), - self.id, - packet.pack_type, - ); - // Send a nack to the previous node - self.send_nack(packet, None, NackType::Dropped); - } else { - warn!( - "{} [ ChatClient {} ]: received a {}", - "!!!".yellow(), - self.id, - packet.pack_type, - ); - self.forward_packet(packet); - } + warn!( + "{} [ ChatClient {} ]: received a {}", + "!!!".yellow(), + self.id, + packet.pack_type, + ); + self.forward_packet(packet); } fn send_nack(&self, mut packet: Packet, fragment: Option, nack_type: NackType) { @@ -490,7 +479,7 @@ impl ChatClient { //there is an error in sending the packet, the drone should send the packet to the simulation controller self.controller_send - .send(DroneEvent::PacketDropped(packet)) + .send(ChatClientEvent::ControllerShortcut(packet)) .unwrap(); warn!( "└─>{} [ ChatClient {} ]: sent A Nack to the Simulation Controller", @@ -526,7 +515,7 @@ impl ChatClient { // Send to the simulation controller self.controller_send - .send(DroneEvent::PacketDropped(packet)) + .send(ChatClientEvent::ControllerShortcut(packet)) .unwrap(); warn!( "└─>{} [ ChatClient {} ]: sent A Nack to the Simulation Controller", @@ -713,7 +702,7 @@ impl ChatClient { warn!("├─>{} Sending to Simulation Controller...", "!!!".yellow()); self.controller_send - .send(DroneEvent::PacketDropped(new_packet)) + .send(ChatClientEvent::ControllerShortcut(new_packet)) .unwrap(); warn!( @@ -736,7 +725,7 @@ impl ChatClient { // Send the packet to the simulation controller self.controller_send - .send(DroneEvent::PacketDropped(new_packet)) + .send(ChatClientEvent::ControllerShortcut(new_packet)) .unwrap(); warn!( @@ -787,7 +776,7 @@ impl ChatClient { warn!("├─>{} Sending to Simulation Controller...", "!!!".yellow()); self.controller_send - .send(DroneEvent::PacketDropped(new_packet)) + .send(ChatClientEvent::ControllerShortcut(new_packet)) .unwrap(); warn!( @@ -809,7 +798,7 @@ impl ChatClient { warn!("├─>{} Sending to Simulation Controller...", "!!!".yellow()); self.controller_send - .send(DroneEvent::PacketDropped(new_packet)) + .send(ChatClientEvent::ControllerShortcut(new_packet)) .unwrap(); warn!(