dev: Announce Responce Cleanup

Author: da2ce7

Cargo.lock

@@ -79,7 +79,14 @@ serde_urlencoded = "0"
 torrust-tracker-test-helpers = { version = "3.0.0-alpha.12-develop", path = "packages/test-helpers" }
 
 [workspace]
-members = ["contrib/bencode", "packages/configuration", "packages/located-error", "packages/primitives", "packages/test-helpers", "packages/torrent-repository-benchmarks"]
+members = [
+    "contrib/bencode",
+    "packages/configuration",
+    "packages/located-error",
+    "packages/primitives",
+    "packages/test-helpers",
+    "packages/torrent-repository-benchmarks",
+]
 
 [profile.dev]
 debug = 1

Cargo.toml

@@ -49,6 +49,7 @@
         "Hydranode",
         "Icelake",
         "imdl",
+        "impls",
         "incompletei",
         "infohash",
         "infohashes",
@@ -79,6 +80,7 @@
         "nonroot",
         "Norberg",
         "numwant",
+        "nvCFlJCq7fz7Qx6KoKTDiMZvns8l5Kw7",
         "oneshot",
         "ostr",
         "Pando",
@@ -129,8 +131,7 @@
         "Xtorrent",
         "Xunlei",
         "xxxxxxxxxxxxxxxxxxxxd",
-        "yyyyyyyyyyyyyyyyyyyyd",
-        "nvCFlJCq7fz7Qx6KoKTDiMZvns8l5Kw7"
+        "yyyyyyyyyyyyyyyyyyyyd"
     ],
     "enableFiletypes": [
         "dockerfile",

cSpell.json

@@ -16,6 +16,7 @@ version.workspace = true
 
 [dependencies]
 config = "0"
+derive_more = "0"
 log = { version = "0", features = ["release_max_level_info"] }
 serde = { version = "1", features = ["derive"] }
 serde_with = "3"

packages/configuration/Cargo.toml

@@ -236,6 +236,7 @@ use std::sync::Arc;
 use std::{env, fs};
 
 use config::{Config, ConfigError, File, FileFormat};
+use derive_more::Constructor;
 use serde::{Deserialize, Serialize};
 use serde_with::{serde_as, NoneAsEmptyString};
 use thiserror::Error;
@@ -303,6 +304,47 @@ impl Info {
     }
 }
 
+/// Announce policy
+#[derive(Copy, Clone, Debug, PartialEq, Constructor)]
+pub struct AnnouncePolicy {
+    /// Interval in seconds that the client should wait between sending regular
+    /// announce requests to the tracker.
+    ///
+    /// It's a **recommended** wait time between announcements.
+    ///
+    /// This is the standard amount of time that clients should wait between
+    /// sending consecutive announcements to the tracker. This value is set by
+    /// the tracker and is typically provided in the tracker's response to a
+    /// client's initial request. It serves as a guideline for clients to know
+    /// how often they should contact the tracker for updates on the peer list,
+    /// while ensuring that the tracker is not overwhelmed with requests.
+    pub interval: u32,
+
+    /// Minimum announce interval. Clients must not reannounce more frequently
+    /// than this.
+    ///
+    /// It establishes the shortest allowed wait time.
+    ///
+    /// This is an optional parameter in the protocol that the tracker may
+    /// provide in its response. It sets a lower limit on the frequency at which
+    /// clients are allowed to send announcements. Clients should respect this
+    /// value to prevent sending too many requests in a short period, which
+    /// could lead to excessive load on the tracker or even getting banned by
+    /// the tracker for not adhering to the rules.
+    pub interval_min: u32,
+}
+
+impl Default for AnnouncePolicy {
+    fn default() -> Self {
+        let announce_interval = 120;
+        let min_announce_interval = 120;
+        Self {
+            interval: announce_interval,
+            interval_min: min_announce_interval,
+        }
+    }
+}
+
 /// Configuration for each UDP tracker.
 #[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
 pub struct UdpTracker {
@@ -516,13 +558,15 @@ impl From<ConfigError> for Error {
 
 impl Default for Configuration {
     fn default() -> Self {
+        let announce_policy = AnnouncePolicy::default();
+
         let mut configuration = Configuration {
             log_level: Option::from(String::from("info")),
             mode: TrackerMode::Public,
             db_driver: DatabaseDriver::Sqlite3,
             db_path: String::from("./storage/tracker/lib/database/sqlite3.db"),
-            announce_interval: 120,
-            min_announce_interval: 120,
+            announce_interval: announce_policy.interval,
+            min_announce_interval: announce_policy.interval_min,
             max_peer_timeout: 900,
             on_reverse_proxy: false,
             external_ip: Some(String::from("0.0.0.0")),

packages/configuration/src/lib.rs

@@ -134,7 +134,7 @@ pub trait Database: Sync + Send {
     /// # Errors
     ///
     /// Will return `Err` if unable to save.
-    async fn save_persistent_torrent(&self, info_hash: &InfoHash, completed: u32) -> Result<(), Error>;
+    async fn save_persistent_torrent(&self, info_hash: &InfoHash, downloaded: u32) -> Result<(), Error>;
 
     // Whitelist
 

src/core/databases/mod.rs

@@ -98,12 +98,12 @@
 //!
 //! ```rust,no_run
 //! use torrust_tracker::core::peer::Peer;
+//! use torrust_tracker_configuration::AnnouncePolicy;
 //!
 //! pub struct AnnounceData {
 //!     pub peers: Vec<Peer>,
 //!     pub swarm_stats: SwarmStats,
-//!     pub interval: u32, // Option `announce_interval` from core tracker configuration
-//!     pub interval_min: u32, // Option `min_announce_interval` from core tracker configuration
+//!     pub policy: AnnouncePolicy, // the tracker announce policy.
 //! }
 //!
 //! pub struct SwarmStats {
@@ -445,9 +445,10 @@ use std::panic::Location;
 use std::sync::Arc;
 use std::time::Duration;
 
+use derive_more::Constructor;
 use futures::future::join_all;
 use tokio::sync::mpsc::error::SendError;
-use torrust_tracker_configuration::Configuration;
+use torrust_tracker_configuration::{AnnouncePolicy, Configuration};
 use torrust_tracker_primitives::TrackerMode;
 
 use self::auth::Key;
@@ -487,7 +488,7 @@ pub struct Tracker {
 /// Structure that holds general `Tracker` torrents metrics.
 ///
 /// Metrics are aggregate values for all torrents.
-#[derive(Debug, PartialEq, Default)]
+#[derive(Copy, Clone, Debug, PartialEq, Default)]
 pub struct TorrentsMetrics {
     /// Total number of seeders for all torrents
     pub seeders: u64,
@@ -500,20 +501,14 @@ pub struct TorrentsMetrics {
 }
 
 /// Structure that holds the data returned by the `announce` request.
-#[derive(Debug, PartialEq, Default)]
+#[derive(Clone, Debug, PartialEq, Constructor, Default)]
 pub struct AnnounceData {
     /// The list of peers that are downloading the same torrent.
     /// It excludes the peer that made the request.
     pub peers: Vec<Peer>,
     /// Swarm statistics
-    pub swarm_stats: SwarmStats,
-    /// The interval in seconds that the client should wait between sending
-    /// regular requests to the tracker.
-    /// Refer to [`announce_interval`](torrust_tracker_configuration::Configuration::announce_interval).
-    pub interval: u32,
-    /// The minimum announce interval in seconds that the client should wait.
-    /// Refer to [`min_announce_interval`](torrust_tracker_configuration::Configuration::min_announce_interval).
-    pub interval_min: u32,
+    pub stats: SwarmStats,
+    pub policy: AnnouncePolicy,
 }
 
 /// Structure that holds the data returned by the `scrape` request.
@@ -628,11 +623,12 @@ impl Tracker {
 
         let peers = self.get_torrent_peers_for_peer(info_hash, peer).await;
 
+        let policy = AnnouncePolicy::new(self.config.announce_interval, self.config.min_announce_interval);
+
         AnnounceData {
             peers,
-            swarm_stats,
-            interval: self.config.announce_interval,
-            interval_min: self.config.min_announce_interval,
+            stats: swarm_stats,
+            policy,
         }
     }
 
@@ -732,7 +728,7 @@ impl Tracker {
         let (stats, stats_updated) = self.torrents.update_torrent_with_peer_and_get_stats(info_hash, peer).await;
 
         if self.config.persistent_torrent_completed_stat && stats_updated {
-            let completed = stats.completed;
+            let completed = stats.downloaded; // i.e `completed`
             let info_hash = *info_hash;
 
             drop(self.database.save_persistent_torrent(&info_hash, completed).await);
@@ -1390,7 +1386,7 @@ mod tests {
 
                         let announce_data = tracker.announce(&sample_info_hash(), &mut peer, &peer_ip()).await;
 
-                        assert_eq!(announce_data.swarm_stats.seeders, 1);
+                        assert_eq!(announce_data.stats.complete, 1);
                     }
 
                     #[tokio::test]
@@ -1401,7 +1397,7 @@ mod tests {
 
                         let announce_data = tracker.announce(&sample_info_hash(), &mut peer, &peer_ip()).await;
 
-                        assert_eq!(announce_data.swarm_stats.leechers, 1);
+                        assert_eq!(announce_data.stats.incomplete, 1);
                     }
 
                     #[tokio::test]
@@ -1415,7 +1411,7 @@ mod tests {
                         let mut completed_peer = completed_peer();
                         let announce_data = tracker.announce(&sample_info_hash(), &mut completed_peer, &peer_ip()).await;
 
-                        assert_eq!(announce_data.swarm_stats.completed, 1);
+                        assert_eq!(announce_data.stats.downloaded, 1);
                     }
                 }
             }
@@ -1739,11 +1735,11 @@ mod tests {
 
                 peer.event = AnnounceEvent::Started;
                 let swarm_stats = tracker.update_torrent_with_peer_and_get_stats(&info_hash, &peer).await;
-                assert_eq!(swarm_stats.completed, 0);
+                assert_eq!(swarm_stats.downloaded, 0);
 
                 peer.event = AnnounceEvent::Completed;
                 let swarm_stats = tracker.update_torrent_with_peer_and_get_stats(&info_hash, &peer).await;
-                assert_eq!(swarm_stats.completed, 1);
+                assert_eq!(swarm_stats.downloaded, 1);
 
                 // Remove the newly updated torrent from memory
                 tracker.torrents.get_torrents_mut().await.remove(&info_hash);

src/core/mod.rs

@@ -277,9 +277,85 @@ impl Serialize for Id {
     }
 }
 
-#[cfg(test)]
-mod test {
+pub mod fixture {
+    use std::net::SocketAddr;
+
+    use aquatic_udp_protocol::NumberOfBytes;
+
+    use super::{Id, Peer};
+
+    #[derive(PartialEq, Debug)]
+
+    pub struct PeerBuilder {
+        peer: Peer,
+    }
+
+    #[allow(clippy::derivable_impls)]
+    impl Default for PeerBuilder {
+        fn default() -> Self {
+            Self { peer: Peer::default() }
+        }
+    }
+
+    impl PeerBuilder {
+        #[allow(dead_code)]
+        #[must_use]
+        pub fn with_peer_id(mut self, peer_id: &Id) -> Self {
+            self.peer.peer_id = *peer_id;
+            self
+        }
+
+        #[allow(dead_code)]
+        #[must_use]
+        pub fn with_peer_addr(mut self, peer_addr: &SocketAddr) -> Self {
+            self.peer.peer_addr = *peer_addr;
+            self
+        }
+
+        #[allow(dead_code)]
+        #[must_use]
+        pub fn with_bytes_pending_to_download(mut self, left: i64) -> Self {
+            self.peer.left = NumberOfBytes(left);
+            self
+        }
 
+        #[allow(dead_code)]
+        #[must_use]
+        pub fn with_no_bytes_pending_to_download(mut self) -> Self {
+            self.peer.left = NumberOfBytes(0);
+            self
+        }
+
+        #[allow(dead_code)]
+        #[must_use]
+        pub fn build(self) -> Peer {
+            self.into()
+        }
+
+        #[allow(dead_code)]
+        #[must_use]
+        pub fn into(self) -> Peer {
+            self.peer
+        }
+    }
+
+    impl Default for Peer {
+        fn default() -> Self {
+            Self {
+                peer_id: Id(*b"-qB00000000000000000"),
+                peer_addr: std::net::SocketAddr::new(std::net::IpAddr::V4(std::net::Ipv4Addr::new(126, 0, 0, 1)), 8080),
+                updated: crate::shared::clock::DurationSinceUnixEpoch::new(1_669_397_478_934, 0),
+                uploaded: NumberOfBytes(0),
+                downloaded: NumberOfBytes(0),
+                left: NumberOfBytes(0),
+                event: aquatic_udp_protocol::AnnounceEvent::Started,
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+pub mod test {
     mod torrent_peer_id {
         use crate::core::peer;