refactor: [torrust#682] handle UDP Tracker timeouts

src/console/clients/udp/checker.rs

@@ -20,6 +20,8 @@ pub enum ClientError {
     NotConnected,
     #[error("Unexpected response while connecting the the remote server.")]
     UnexpectedConnectionResponse,
+    #[error("Connection timeout.")]
+    ConnectionTimeout,
 }
 
 /// A UDP Tracker client to make test requests (checks).

src/shared/bit_torrent/tracker/udp/client.rs

@@ -4,12 +4,13 @@ use std::net::SocketAddr;
 use std::sync::Arc;
 use std::time::Duration;
 
-use anyhow::{anyhow, Context, Result};
+use anyhow::{anyhow, bail, Context, Result};
 use aquatic_udp_protocol::{ConnectRequest, Request, Response, TransactionId};
 use log::debug;
 use tokio::net::UdpSocket;
 use tokio::time;
 
+use crate::console::clients::udp::checker::ClientError;
 use crate::shared::bit_torrent::tracker::udp::{source_address, MAX_PACKET_SIZE};
 
 /// Default timeout for sending and receiving packets. And waiting for sockets
@@ -78,15 +79,15 @@ impl UdpClient {
                     Err(e) => return Err(anyhow!("IO error waiting for the socket to become readable: {e:?}")),
                 };
             }
-            Err(e) => return Err(anyhow!("Timeout waiting for the socket to become readable: {e:?}")),
+            Err(_) => bail!(ClientError::ConnectionTimeout),
         };
 
         match time::timeout(self.timeout, self.socket.send(bytes)).await {
             Ok(send_result) => match send_result {
                 Ok(size) => Ok(size),
                 Err(e) => Err(anyhow!("IO error during send: {e:?}")),
             },
-            Err(e) => Err(anyhow!("Send operation timed out: {e:?}")),
+            Err(_) => bail!(ClientError::ConnectionTimeout),
         }
     }
 
@@ -109,15 +110,15 @@ impl UdpClient {
                     Err(e) => return Err(anyhow!("IO error waiting for the socket to become readable: {e:?}")),
                 };
             }
-            Err(e) => return Err(anyhow!("Timeout waiting for the socket to become readable: {e:?}")),
+            Err(_) => bail!(ClientError::ConnectionTimeout),
         };
 
         let size_result = match time::timeout(self.timeout, self.socket.recv(bytes)).await {
             Ok(recv_result) => match recv_result {
                 Ok(size) => Ok(size),
                 Err(e) => Err(anyhow!("IO error during send: {e:?}")),
             },
-            Err(e) => Err(anyhow!("Receive operation timed out: {e:?}")),
+            Err(_) => bail!(ClientError::ConnectionTimeout),
         };
 
         if size_result.is_ok() {