clippy: fix src/tracker/peer.rs

Author: da2ce7

src/api/resources/torrent_resource.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-use crate::tracker::peer::{self, TorrentPeer};
+use crate::tracker::peer::{self, Peer};
 
 #[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
 pub struct TorrentResource {
@@ -50,9 +50,9 @@ impl From<peer::Id> for PeerIdResource {
     }
 }
 
-impl From<TorrentPeer> for TorrentPeerResource {
+impl From<Peer> for TorrentPeerResource {
     #[allow(deprecated)]
-    fn from(peer: TorrentPeer) -> Self {
+    fn from(peer: Peer) -> Self {
         TorrentPeerResource {
             peer_id: PeerIdResource::from(peer.peer_id),
             peer_addr: peer.peer_addr.to_string(),

src/http/handlers.rs

@@ -48,8 +48,7 @@ pub async fn handle_announce(
 
     debug!("{:?}", announce_request);
 
-    let peer =
-        peer::TorrentPeer::from_http_announce_request(&announce_request, announce_request.peer_addr, tracker.config.get_ext_ip());
+    let peer = peer::Peer::from_http_announce_request(&announce_request, announce_request.peer_addr, tracker.config.get_ext_ip());
     let torrent_stats = tracker
         .update_torrent_with_peer_and_get_stats(&announce_request.info_hash, &peer)
         .await;
@@ -137,7 +136,7 @@ pub async fn handle_scrape(
 fn send_announce_response(
     announce_request: &request::Announce,
     torrent_stats: &torrent::Stats,
-    peers: &Vec<peer::TorrentPeer>,
+    peers: &Vec<peer::Peer>,
     interval: u32,
     interval_min: u32,
 ) -> WebResult<impl Reply> {

src/tracker/mod.rs

@@ -227,7 +227,7 @@ impl Tracker {
     }
 
     /// Get all torrent peers for a given torrent filtering out the peer with the client address
-    pub async fn get_torrent_peers(&self, info_hash: &InfoHash, client_addr: &SocketAddr) -> Vec<peer::TorrentPeer> {
+    pub async fn get_torrent_peers(&self, info_hash: &InfoHash, client_addr: &SocketAddr) -> Vec<peer::Peer> {
         let read_lock = self.torrents.read().await;
 
         match read_lock.get(info_hash) {
@@ -237,7 +237,7 @@ impl Tracker {
     }
 
     /// Get all torrent peers for a given torrent
-    pub async fn get_all_torrent_peers(&self, info_hash: &InfoHash) -> Vec<peer::TorrentPeer> {
+    pub async fn get_all_torrent_peers(&self, info_hash: &InfoHash) -> Vec<peer::Peer> {
         let read_lock = self.torrents.read().await;
 
         match read_lock.get(info_hash) {
@@ -246,7 +246,7 @@ impl Tracker {
         }
     }
 
-    pub async fn update_torrent_with_peer_and_get_stats(&self, info_hash: &InfoHash, peer: &peer::TorrentPeer) -> torrent::Stats {
+    pub async fn update_torrent_with_peer_and_get_stats(&self, info_hash: &InfoHash, peer: &peer::Peer) -> torrent::Stats {
         let mut torrents = self.torrents.write().await;
 
         let torrent_entry = match torrents.entry(*info_hash) {

src/tracker/peer.rs

@@ -10,7 +10,7 @@ use crate::protocol::common::{AnnounceEventDef, NumberOfBytesDef};
 use crate::protocol::utils::ser_unix_time_value;
 
 #[derive(PartialEq, Eq, Debug, Clone, Serialize, Copy)]
-pub struct TorrentPeer {
+pub struct Peer {
     pub peer_id: Id,
     pub peer_addr: SocketAddr,
     #[serde(serialize_with = "ser_unix_time_value")]
@@ -25,16 +25,16 @@ pub struct TorrentPeer {
     pub event: AnnounceEvent,
 }
 
-impl TorrentPeer {
+impl Peer {
     #[must_use]
     pub fn from_udp_announce_request(
         announce_request: &aquatic_udp_protocol::AnnounceRequest,
         remote_ip: IpAddr,
         host_opt_ip: Option<IpAddr>,
     ) -> Self {
-        let peer_addr = TorrentPeer::peer_addr_from_ip_and_port_and_opt_host_ip(remote_ip, host_opt_ip, announce_request.port.0);
+        let peer_addr = Peer::peer_addr_from_ip_and_port_and_opt_host_ip(remote_ip, host_opt_ip, announce_request.port.0);
 
-        TorrentPeer {
+        Peer {
             peer_id: Id(announce_request.peer_id.0),
             peer_addr,
             updated: Current::now(),
@@ -47,7 +47,7 @@ impl TorrentPeer {
 
     #[must_use]
     pub fn from_http_announce_request(announce_request: &Announce, remote_ip: IpAddr, host_opt_ip: Option<IpAddr>) -> Self {
-        let peer_addr = TorrentPeer::peer_addr_from_ip_and_port_and_opt_host_ip(remote_ip, host_opt_ip, announce_request.port);
+        let peer_addr = Peer::peer_addr_from_ip_and_port_and_opt_host_ip(remote_ip, host_opt_ip, announce_request.port);
 
         let event: AnnounceEvent = if let Some(event) = &announce_request.event {
             match event.as_ref() {
@@ -61,8 +61,8 @@ impl TorrentPeer {
         };
 
         #[allow(clippy::cast_possible_truncation)]
-        TorrentPeer {
-            peer_id: announce_request.peer_id.clone(),
+        Peer {
+            peer_id: announce_request.peer_id,
             peer_addr,
             updated: Current::now(),
             uploaded: NumberOfBytes(i128::from(announce_request.uploaded) as i64),
@@ -104,6 +104,9 @@ impl std::fmt::Display for Id {
 
 impl Id {
     #[must_use]
+    /// # Panics
+    ///
+    /// It will panic if the `binascii::bin2hex` from a too-small output buffer.
     pub fn get_id(&self) -> Option<String> {
         let buff_size = self.0.len() * 2;
         let mut tmp: Vec<u8> = vec![0; buff_size];
@@ -202,11 +205,6 @@ impl Serialize for Id {
             client: Option<&'a str>,
         }
 
-        let buff_size = self.0.len() * 2;
-        let mut tmp: Vec<u8> = vec![0; buff_size];
-        binascii::bin2hex(&self.0, &mut tmp).unwrap();
-        let id = std::str::from_utf8(&tmp).ok();
-
         let obj = PeerIdInfo {
             id: self.get_id(),
             client: self.get_client_name(),
@@ -224,11 +222,11 @@ mod test {
         use aquatic_udp_protocol::{AnnounceEvent, NumberOfBytes};
 
         use crate::protocol::clock::{Current, Time};
-        use crate::tracker::peer::{self, TorrentPeer};
+        use crate::tracker::peer::{self, Peer};
 
         #[test]
         fn it_should_be_serializable() {
-            let torrent_peer = TorrentPeer {
+            let torrent_peer = Peer {
                 peer_id: peer::Id(*b"-qB00000000000000000"),
                 peer_addr: SocketAddr::new(IpAddr::V4(Ipv4Addr::new(126, 0, 0, 1)), 8080),
                 updated: Current::now(),
@@ -256,7 +254,7 @@ mod test {
             AnnounceEvent, AnnounceRequest, NumberOfBytes, NumberOfPeers, PeerId as AquaticPeerId, PeerKey, Port, TransactionId,
         };
 
-        use crate::tracker::peer::TorrentPeer;
+        use crate::tracker::peer::Peer;
         use crate::udp::connection_cookie::{into_connection_id, make};
 
         // todo: duplicate functions is PR 82. Remove duplication once both PR are merged.
@@ -308,7 +306,7 @@ mod test {
             let remote_ip = IpAddr::V4(Ipv4Addr::new(126, 0, 0, 2));
             let announce_request = AnnounceRequestBuilder::default().into();
 
-            let torrent_peer = TorrentPeer::from_udp_announce_request(&announce_request, remote_ip, None);
+            let torrent_peer = Peer::from_udp_announce_request(&announce_request, remote_ip, None);
 
             assert_eq!(torrent_peer.peer_addr, SocketAddr::new(remote_ip, announce_request.port.0));
         }
@@ -318,7 +316,7 @@ mod test {
             let remote_ip = IpAddr::V4(Ipv4Addr::new(126, 0, 0, 2));
             let announce_request = AnnounceRequestBuilder::default().into();
 
-            let torrent_peer = TorrentPeer::from_udp_announce_request(&announce_request, remote_ip, None);
+            let torrent_peer = Peer::from_udp_announce_request(&announce_request, remote_ip, None);
 
             assert_eq!(torrent_peer.peer_addr, SocketAddr::new(remote_ip, announce_request.port.0));
         }
@@ -329,14 +327,14 @@ mod test {
             use std::str::FromStr;
 
             use crate::tracker::peer::test::torrent_peer_constructor_from_udp_requests::AnnounceRequestBuilder;
-            use crate::tracker::peer::TorrentPeer;
+            use crate::tracker::peer::Peer;
 
             #[test]
             fn it_should_use_the_loopback_ip_if_the_server_does_not_have_the_external_ip_configuration() {
                 let remote_ip = IpAddr::V4(Ipv4Addr::LOCALHOST);
                 let announce_request = AnnounceRequestBuilder::default().into();
 
-                let torrent_peer = TorrentPeer::from_udp_announce_request(&announce_request, remote_ip, None);
+                let torrent_peer = Peer::from_udp_announce_request(&announce_request, remote_ip, None);
 
                 assert_eq!(torrent_peer.peer_addr, SocketAddr::new(remote_ip, announce_request.port.0));
             }
@@ -347,7 +345,7 @@ mod test {
                 let announce_request = AnnounceRequestBuilder::default().into();
 
                 let host_opt_ip = IpAddr::V4(Ipv4Addr::from_str("126.0.0.1").unwrap());
-                let torrent_peer = TorrentPeer::from_udp_announce_request(&announce_request, remote_ip, Some(host_opt_ip));
+                let torrent_peer = Peer::from_udp_announce_request(&announce_request, remote_ip, Some(host_opt_ip));
 
                 assert_eq!(torrent_peer.peer_addr, SocketAddr::new(host_opt_ip, announce_request.port.0));
             }
@@ -358,7 +356,7 @@ mod test {
                 let announce_request = AnnounceRequestBuilder::default().into();
 
                 let host_opt_ip = IpAddr::V6(Ipv6Addr::from_str("2345:0425:2CA1:0000:0000:0567:5673:23b5").unwrap());
-                let torrent_peer = TorrentPeer::from_udp_announce_request(&announce_request, remote_ip, Some(host_opt_ip));
+                let torrent_peer = Peer::from_udp_announce_request(&announce_request, remote_ip, Some(host_opt_ip));
 
                 assert_eq!(torrent_peer.peer_addr, SocketAddr::new(host_opt_ip, announce_request.port.0));
             }
@@ -370,14 +368,14 @@ mod test {
             use std::str::FromStr;
 
             use crate::tracker::peer::test::torrent_peer_constructor_from_udp_requests::AnnounceRequestBuilder;
-            use crate::tracker::peer::TorrentPeer;
+            use crate::tracker::peer::Peer;
 
             #[test]
             fn it_should_use_the_loopback_ip_if_the_server_does_not_have_the_external_ip_configuration() {
                 let remote_ip = IpAddr::V6(Ipv6Addr::LOCALHOST);
                 let announce_request = AnnounceRequestBuilder::default().into();
 
-                let torrent_peer = TorrentPeer::from_udp_announce_request(&announce_request, remote_ip, None);
+                let torrent_peer = Peer::from_udp_announce_request(&announce_request, remote_ip, None);
 
                 assert_eq!(torrent_peer.peer_addr, SocketAddr::new(remote_ip, announce_request.port.0));
             }
@@ -388,7 +386,7 @@ mod test {
                 let announce_request = AnnounceRequestBuilder::default().into();
 
                 let host_opt_ip = IpAddr::V6(Ipv6Addr::from_str("2345:0425:2CA1:0000:0000:0567:5673:23b5").unwrap());
-                let torrent_peer = TorrentPeer::from_udp_announce_request(&announce_request, remote_ip, Some(host_opt_ip));
+                let torrent_peer = Peer::from_udp_announce_request(&announce_request, remote_ip, Some(host_opt_ip));
 
                 assert_eq!(torrent_peer.peer_addr, SocketAddr::new(host_opt_ip, announce_request.port.0));
             }
@@ -399,7 +397,7 @@ mod test {
                 let announce_request = AnnounceRequestBuilder::default().into();
 
                 let host_opt_ip = IpAddr::V4(Ipv4Addr::from_str("126.0.0.1").unwrap());
-                let torrent_peer = TorrentPeer::from_udp_announce_request(&announce_request, remote_ip, Some(host_opt_ip));
+                let torrent_peer = Peer::from_udp_announce_request(&announce_request, remote_ip, Some(host_opt_ip));
 
                 assert_eq!(torrent_peer.peer_addr, SocketAddr::new(host_opt_ip, announce_request.port.0));
             }
@@ -411,7 +409,7 @@ mod test {
 
         use crate::http::request::Announce;
         use crate::protocol::info_hash::InfoHash;
-        use crate::tracker::peer::{self, TorrentPeer};
+        use crate::tracker::peer::{self, Peer};
 
         fn sample_http_announce_request(peer_addr: IpAddr, port: u16) -> Announce {
             Announce {
@@ -434,7 +432,7 @@ mod test {
             let ip_in_announce_request = IpAddr::V4(Ipv4Addr::new(126, 0, 0, 1));
             let announce_request = sample_http_announce_request(ip_in_announce_request, 8080);
 
-            let torrent_peer = TorrentPeer::from_http_announce_request(&announce_request, remote_ip, None);
+            let torrent_peer = Peer::from_http_announce_request(&announce_request, remote_ip, None);
 
             assert_eq!(torrent_peer.peer_addr.ip(), remote_ip);
             assert_ne!(torrent_peer.peer_addr.ip(), ip_in_announce_request);
@@ -449,7 +447,7 @@ mod test {
             let announce_request =
                 sample_http_announce_request(IpAddr::V4(Ipv4Addr::new(126, 0, 0, 1)), port_in_announce_request);
 
-            let torrent_peer = TorrentPeer::from_http_announce_request(&announce_request, remote_ip, None);
+            let torrent_peer = Peer::from_http_announce_request(&announce_request, remote_ip, None);
 
             assert_eq!(torrent_peer.peer_addr.port(), announce_request.port);
             assert_ne!(torrent_peer.peer_addr.port(), remote_port);

src/tracker/torrent.rs

@@ -11,7 +11,7 @@ use crate::protocol::common::MAX_SCRAPE_TORRENTS;
 #[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct Entry {
     #[serde(skip)]
-    pub peers: std::collections::BTreeMap<peer::Id, peer::TorrentPeer>,
+    pub peers: std::collections::BTreeMap<peer::Id, peer::Peer>,
     pub completed: u32,
 }
 
@@ -25,7 +25,7 @@ impl Entry {
     }
 
     // Update peer and return completed (times torrent has been downloaded)
-    pub fn update_peer(&mut self, peer: &peer::TorrentPeer) -> bool {
+    pub fn update_peer(&mut self, peer: &peer::Peer) -> bool {
         let mut did_torrent_stats_change: bool = false;
 
         match peer.event {
@@ -49,7 +49,7 @@ impl Entry {
     }
 
     #[must_use]
-    pub fn get_peers(&self, client_addr: Option<&SocketAddr>) -> Vec<&peer::TorrentPeer> {
+    pub fn get_peers(&self, client_addr: Option<&SocketAddr>) -> Vec<&peer::Peer> {
         self.peers
             .values()
             .filter(|peer| match client_addr {
@@ -122,12 +122,12 @@ mod tests {
     use crate::tracker::torrent::Entry;
 
     struct TorrentPeerBuilder {
-        peer: peer::TorrentPeer,
+        peer: peer::Peer,
     }
 
     impl TorrentPeerBuilder {
         pub fn default() -> TorrentPeerBuilder {
-            let default_peer = peer::TorrentPeer {
+            let default_peer = peer::Peer {
                 peer_id: peer::Id([0u8; 20]),
                 peer_addr: SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080),
                 updated: Current::now(),
@@ -164,14 +164,14 @@ mod tests {
             self
         }
 
-        pub fn into(self) -> peer::TorrentPeer {
+        pub fn into(self) -> peer::Peer {
             self.peer
         }
     }
 
     /// A torrent seeder is a peer with 0 bytes left to download which
     /// has not announced it has stopped
-    fn a_torrent_seeder() -> peer::TorrentPeer {
+    fn a_torrent_seeder() -> peer::Peer {
         TorrentPeerBuilder::default()
             .with_number_of_bytes_left(0)
             .with_event_completed()
@@ -180,7 +180,7 @@ mod tests {
 
     /// A torrent leecher is a peer that is not a seeder.
     /// Leecher: left > 0 OR event = Stopped
-    fn a_torrent_leecher() -> peer::TorrentPeer {
+    fn a_torrent_leecher() -> peer::Peer {
         TorrentPeerBuilder::default()
             .with_number_of_bytes_left(1)
             .with_event_completed()

src/udp/handlers.rs

@@ -92,7 +92,7 @@ pub async fn handle_announce(
         .authenticate_request(&wrapped_announce_request.info_hash, &None)
         .await?;
 
-    let peer = peer::TorrentPeer::from_udp_announce_request(
+    let peer = peer::Peer::from_udp_announce_request(
         &wrapped_announce_request.announce_request,
         remote_addr.ip(),
         tracker.config.get_ext_ip(),
@@ -289,12 +289,12 @@ mod tests {
     }
 
     struct TorrentPeerBuilder {
-        peer: peer::TorrentPeer,
+        peer: peer::Peer,
     }
 
     impl TorrentPeerBuilder {
         pub fn default() -> TorrentPeerBuilder {
-            let default_peer = peer::TorrentPeer {
+            let default_peer = peer::Peer {
                 peer_id: peer::Id([255u8; 20]),
                 peer_addr: SocketAddr::new(IpAddr::V4(Ipv4Addr::new(126, 0, 0, 1)), 8080),
                 updated: Current::now(),
@@ -321,7 +321,7 @@ mod tests {
             self
         }
 
-        pub fn into(self) -> peer::TorrentPeer {
+        pub fn into(self) -> peer::Peer {
             self.peer
         }
     }

tests/api.rs

@@ -24,7 +24,7 @@ mod tracker_api {
     use torrust_tracker::protocol::clock::DurationSinceUnixEpoch;
     use torrust_tracker::protocol::info_hash::InfoHash;
     use torrust_tracker::tracker::auth;
-    use torrust_tracker::tracker::peer::{self, TorrentPeer};
+    use torrust_tracker::tracker::peer::{self, Peer};
     use torrust_tracker::tracker::statistics::Keeper;
     use torrust_tracker::{ephemeral_instance_keys, logging, static_time, tracker};
 
@@ -187,8 +187,8 @@ mod tracker_api {
         );
     }
 
-    fn sample_torrent_peer() -> (TorrentPeer, TorrentPeerResource) {
-        let torrent_peer = TorrentPeer {
+    fn sample_torrent_peer() -> (Peer, TorrentPeerResource) {
+        let torrent_peer = Peer {
             peer_id: peer::Id(*b"-qB00000000000000000"),
             peer_addr: SocketAddr::new(IpAddr::V4(Ipv4Addr::new(126, 0, 0, 1)), 8080),
             updated: DurationSinceUnixEpoch::new(1_669_397_478_934, 0),