clippy: fix src/tracker/peer.rs

Author: da2ce7

src/http/handlers.rs

@@ -13,10 +13,9 @@ use super::{request, WebResult};
 use crate::http::response::Error;
 use crate::protocol::common::InfoHash;
 use crate::tracker::key::Auth;
-use crate::tracker::peer::TorrentPeer;
 use crate::tracker::statistics::TrackerStatisticsEvent;
 use crate::tracker::torrent::{TorrentError, TorrentStats};
-use crate::tracker::TorrentTracker;
+use crate::tracker::{peer, TorrentTracker};
 
 /// Authenticate `InfoHash` using optional `AuthKey`
 ///
@@ -55,7 +54,7 @@ pub async fn handle_announce(
     debug!("{:?}", announce_request);
 
     let peer =
-        TorrentPeer::from_http_announce_request(&announce_request, announce_request.peer_addr, tracker.config.get_ext_ip());
+        peer::TorrentPeer::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;
@@ -143,7 +142,7 @@ pub async fn handle_scrape(
 fn send_announce_response(
     announce_request: &request::Announce,
     torrent_stats: &TorrentStats,
-    peers: &Vec<TorrentPeer>,
+    peers: &Vec<peer::TorrentPeer>,
     interval: u32,
     interval_min: u32,
 ) -> WebResult<impl Reply> {

src/tracker/mod.rs

@@ -13,7 +13,6 @@ use std::time::Duration;
 use tokio::sync::mpsc::error::SendError;
 use tokio::sync::{RwLock, RwLockReadGuard};
 
-use self::peer::TorrentPeer;
 use self::statistics::{StatsRepository, TrackerStatistics, TrackerStatisticsEvent, TrackerStatisticsEventSender};
 use crate::config::Configuration;
 use crate::databases::database;
@@ -195,7 +194,7 @@ impl TorrentTracker {
     }
 
     /// 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<TorrentPeer> {
+    pub async fn get_torrent_peers(&self, info_hash: &InfoHash, client_addr: &SocketAddr) -> Vec<peer::TorrentPeer> {
         let read_lock = self.torrents.read().await;
 
         match read_lock.get(info_hash) {
@@ -205,7 +204,7 @@ impl TorrentTracker {
     }
 
     /// Get all torrent peers for a given torrent
-    pub async fn get_all_torrent_peers(&self, info_hash: &InfoHash) -> Vec<TorrentPeer> {
+    pub async fn get_all_torrent_peers(&self, info_hash: &InfoHash) -> Vec<peer::TorrentPeer> {
         let read_lock = self.torrents.read().await;
 
         match read_lock.get(info_hash) {
@@ -214,7 +213,7 @@ impl TorrentTracker {
         }
     }
 
-    pub async fn update_torrent_with_peer_and_get_stats(&self, info_hash: &InfoHash, peer: &TorrentPeer) -> TorrentStats {
+    pub async fn update_torrent_with_peer_and_get_stats(&self, info_hash: &InfoHash, peer: &peer::TorrentPeer) -> TorrentStats {
         let mut torrents = self.torrents.write().await;
 
         let torrent_entry = match torrents.entry(*info_hash) {

src/tracker/peer.rs

@@ -60,13 +60,14 @@ impl TorrentPeer {
             AnnounceEvent::None
         };
 
+        #[allow(clippy::cast_possible_truncation)]
         TorrentPeer {
-            peer_id: announce_request.peer_id,
+            peer_id: announce_request.peer_id.clone(),
             peer_addr,
             updated: Current::now(),
-            uploaded: NumberOfBytes(announce_request.uploaded as i64),
-            downloaded: NumberOfBytes(announce_request.downloaded as i64),
-            left: NumberOfBytes(announce_request.left as i64),
+            uploaded: NumberOfBytes(i128::from(announce_request.uploaded) as i64),
+            downloaded: NumberOfBytes(i128::from(announce_request.downloaded) as i64),
+            left: NumberOfBytes(i128::from(announce_request.left) as i64),
             event,
         }
     }

src/tracker/torrent.rs

@@ -4,14 +4,14 @@ use std::time::Duration;
 use aquatic_udp_protocol::AnnounceEvent;
 use serde::{Deserialize, Serialize};
 
-use super::peer::TorrentPeer;
+use super::peer;
 use crate::protocol::clock::{Current, TimeNow};
 use crate::protocol::common::{PeerId, MAX_SCRAPE_TORRENTS};
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct TorrentEntry {
     #[serde(skip)]
-    pub peers: std::collections::BTreeMap<PeerId, TorrentPeer>,
+    pub peers: std::collections::BTreeMap<PeerId, peer::TorrentPeer>,
     pub completed: u32,
 }
 
@@ -25,7 +25,7 @@ impl TorrentEntry {
     }
 
     // Update peer and return completed (times torrent has been downloaded)
-    pub fn update_peer(&mut self, peer: &TorrentPeer) -> bool {
+    pub fn update_peer(&mut self, peer: &peer::TorrentPeer) -> bool {
         let mut did_torrent_stats_change: bool = false;
 
         match peer.event {
@@ -49,7 +49,7 @@ impl TorrentEntry {
     }
 
     #[must_use]
-    pub fn get_peers(&self, client_addr: Option<&SocketAddr>) -> Vec<&TorrentPeer> {
+    pub fn get_peers(&self, client_addr: Option<&SocketAddr>) -> Vec<&peer::TorrentPeer> {
         self.peers
             .values()
             .filter(|peer| match client_addr {
@@ -118,16 +118,16 @@ mod tests {
 
     use crate::protocol::clock::{Current, DurationSinceUnixEpoch, Stopped, StoppedTime, Time, Working};
     use crate::protocol::common::PeerId;
-    use crate::tracker::peer::TorrentPeer;
+    use crate::tracker::peer;
     use crate::tracker::torrent::TorrentEntry;
 
     struct TorrentPeerBuilder {
-        peer: TorrentPeer,
+        peer: peer::TorrentPeer,
     }
 
     impl TorrentPeerBuilder {
         pub fn default() -> TorrentPeerBuilder {
-            let default_peer = TorrentPeer {
+            let default_peer = peer::TorrentPeer {
                 peer_id: PeerId([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) -> TorrentPeer {
+        pub fn into(self) -> peer::TorrentPeer {
             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() -> TorrentPeer {
+    fn a_torrent_seeder() -> peer::TorrentPeer {
         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() -> TorrentPeer {
+    fn a_torrent_leecher() -> peer::TorrentPeer {
         TorrentPeerBuilder::default()
             .with_number_of_bytes_left(1)
             .with_event_completed()

src/udp/handlers.rs

@@ -8,10 +8,9 @@ use aquatic_udp_protocol::{
 
 use super::connection_cookie::{check_connection_cookie, from_connection_id, into_connection_id, make_connection_cookie};
 use crate::protocol::common::{InfoHash, MAX_SCRAPE_TORRENTS};
-use crate::tracker::peer::TorrentPeer;
 use crate::tracker::statistics::TrackerStatisticsEvent;
 use crate::tracker::torrent::TorrentError;
-use crate::tracker::TorrentTracker;
+use crate::tracker::{peer, TorrentTracker};
 use crate::udp::errors::ServerError;
 use crate::udp::request::AnnounceRequestWrapper;
 
@@ -106,7 +105,7 @@ pub async fn handle_announce(
 
     authenticate(&wrapped_announce_request.info_hash, tracker.clone()).await?;
 
-    let peer = TorrentPeer::from_udp_announce_request(
+    let peer = peer::TorrentPeer::from_udp_announce_request(
         &wrapped_announce_request.announce_request,
         remote_addr.ip(),
         tracker.config.get_ext_ip(),
@@ -255,9 +254,8 @@ mod tests {
     use crate::config::Configuration;
     use crate::protocol::clock::{Current, Time};
     use crate::protocol::common::PeerId;
-    use crate::tracker::peer::TorrentPeer;
     use crate::tracker::statistics::StatsTracker;
-    use crate::tracker::{mode, TorrentTracker};
+    use crate::tracker::{mode, peer, TorrentTracker};
 
     fn default_tracker_config() -> Arc<Configuration> {
         Arc::new(Configuration::default())
@@ -304,12 +302,12 @@ mod tests {
     }
 
     struct TorrentPeerBuilder {
-        peer: TorrentPeer,
+        peer: peer::TorrentPeer,
     }
 
     impl TorrentPeerBuilder {
         pub fn default() -> TorrentPeerBuilder {
-            let default_peer = TorrentPeer {
+            let default_peer = peer::TorrentPeer {
                 peer_id: PeerId([255u8; 20]),
                 peer_addr: SocketAddr::new(IpAddr::V4(Ipv4Addr::new(126, 0, 0, 1)), 8080),
                 updated: Current::now(),
@@ -336,7 +334,7 @@ mod tests {
             self
         }
 
-        pub fn into(self) -> TorrentPeer {
+        pub fn into(self) -> peer::TorrentPeer {
             self.peer
         }
     }