lint: Fix clippy warnings

Signed-off-by: rrouviere <ruben.rouviere@etu.umontpellier.fr>

Author: ruben-etu

topics/p2p-transfer-protocol/src/client/mod.rs

@@ -26,11 +26,11 @@ pub fn run_client(mut file: File, mut stream: TcpStream) -> io::Result<()> {
     reader.read_line(&mut response)?;
     let response = response.trim();
     match response.parse::<Message>() {
-        Ok(Message::ACK) => {
+        Ok(Message::Ack) => {
             debug!("Received ACK");
             sm.transition(ConnectionState::ACKReceived);
         }
-        Ok(Message::NACK) => {
+        Ok(Message::Nack) => {
             debug!("Received NACK");
             sm.transition(ConnectionState::NACKReceived);
             return Ok(());

topics/p2p-transfer-protocol/src/main.rs

@@ -65,7 +65,7 @@ fn main() {
 fn server_mode(bind_addr: &str, file_path: &str) -> io::Result<()> {
     // Start server
     // Bind to port: bind_addr
-    let listener = match TcpListener::bind(&bind_addr) {
+    let listener = match TcpListener::bind(bind_addr) {
         Ok(l) => l,
         Err(e) => {
             error!("Failed to bind to {}: {}", bind_addr, e);
@@ -76,6 +76,7 @@ fn server_mode(bind_addr: &str, file_path: &str) -> io::Result<()> {
 
     // Open or create output file:
     let mut file = OpenOptions::new()
+        .truncate(true)
         .write(true)
         .create(true)
         .open(file_path)?;

topics/p2p-transfer-protocol/src/protocol/message.rs

@@ -4,19 +4,19 @@ use std::{fmt::Display, str::FromStr};
 #[derive(Debug, PartialEq, Eq)]
 pub enum Message {
     Hello { file_size: u64 },
-    ACK,
-    NACK,
+    Ack,
+    Nack,
     Send,
 }
 
 // Wire format
 impl Display for Message {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Message::Hello { file_size } => write!(f, "HELLO {file_size}\n"),
-            Message::ACK => write!(f, "ACK\n"),
-            Message::NACK => write!(f, "NACK\n"),
-            Message::Send => write!(f, "SEND\n"),
+            Message::Hello { file_size } => writeln!(f, "HELLO {file_size}"),
+            Message::Ack => writeln!(f, "ACK"),
+            Message::Nack => writeln!(f, "NACK"),
+            Message::Send => writeln!(f, "SEND"),
         }
     }
 }
@@ -31,22 +31,21 @@ impl FromStr for Message {
 
         if upper.starts_with("HELLO") {
             let parts: Vec<&str> = s.split_whitespace().collect();
-            if parts.len() == 2 {
-                if let Ok(file_size) = parts[1].parse::<u64>() {
+            if parts.len() == 2
+                && let Ok(file_size) = parts[1].parse::<u64>() {
                     return Ok(Message::Hello { file_size });
                 }
-            }
             error!("Invalid HELLO message");
             return Err(());
         };
 
         // No arguments msgs
-        return match upper.as_str() {
-            "ACK" => Ok(Message::ACK),
-            "NACK" => Ok(Message::NACK),
+        match upper.as_str() {
+            "ACK" => Ok(Message::Ack),
+            "NACK" => Ok(Message::Nack),
             "SEND" => Ok(Message::Send),
             // Unknown message
             _ => Err(()),
-        };
+        }
     }
 }

topics/p2p-transfer-protocol/src/server/mod.rs

@@ -18,11 +18,11 @@ fn on_hello(file_size: u64, state_machine: &mut StateMachine) -> Message {
     // send ack
     state_machine.transition(ConnectionState::ACKSent);
 
-    Message::ACK
+    Message::Ack
 }
 
 fn on_message(msg: Message, state_machine: &mut StateMachine) -> Option<Message> {
-    return match msg {
+    match msg {
         Message::Hello { file_size } => Some(on_hello(file_size, state_machine)),
         Message::Send => {
             info!("Client is starting to send data.");
@@ -34,7 +34,7 @@ fn on_message(msg: Message, state_machine: &mut StateMachine) -> Option<Message>
             warn!("Unexpected message from client: {:?}", msg);
             None
         }
-    };
+    }
 }
 
 fn send_message(stream: &mut TcpStream, msg: &Message) -> Result<(), io::Error> {
@@ -89,7 +89,7 @@ fn receive_file(
 
 fn message_loop(state_machine: &mut StateMachine, stream: &mut TcpStream) -> Result<(), io::Error> {
     let reader_stream = stream.try_clone().expect("Failed to clone stream");
-    let mut writer_stream = stream;
+    let writer_stream = stream;
     let reader = BufReader::new(reader_stream);
 
     for line in reader.lines() {
@@ -106,10 +106,8 @@ fn message_loop(state_machine: &mut StateMachine, stream: &mut TcpStream) -> Res
 
         // Process message
         // FIXME: Do not use unwrap, fix the result type mess.
-        match on_message(message.unwrap(), state_machine) {
-            Some(resp) => send_message(&mut writer_stream, &resp)?,
-            None => {} // No response is needed
-        }
+        if let Some(resp) = on_message(message.unwrap(), state_machine) { send_message(writer_stream, &resp)? }
+
         // If we are in Established state, stop the line-based logic and receive the data.
         if let ConnectionState::Established = state_machine.current_state() {
             break;