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

@@ -50,6 +50,7 @@
         "Hydranode",
         "Icelake",
         "imdl",
+        "impls",
         "incompletei",
         "infohash",
         "infohashes",

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;
@@ -388,7 +389,7 @@ pub struct HealthCheckApi {
 }
 
 /// Announce policy
-#[derive(PartialEq, Eq, Debug, Clone, Copy)]
+#[derive(PartialEq, Eq, Debug, Clone, Copy, Constructor)]
 pub struct AnnouncePolicy {
     /// Interval in seconds that the client should wait between sending regular
     /// announce requests to the tracker.
@@ -537,6 +538,7 @@ 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,

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,
         }
     }
 
@@ -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.complete, 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.incomplete, 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.downloaded, 1);
+                        assert_eq!(announce_data.stats.downloaded, 1);
                     }
                 }
             }

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;
 

src/core/peer.rs

@@ -33,6 +33,7 @@ pub mod repository;
 use std::time::Duration;
 
 use aquatic_udp_protocol::AnnounceEvent;
+use derive_more::Constructor;
 use serde::{Deserialize, Serialize};
 
 use super::peer::{self, Peer};
@@ -56,13 +57,13 @@ pub struct Entry {
 /// Swarm metadata dictionary in the scrape response.
 ///
 /// See [BEP 48: Tracker Protocol Extension: Scrape](https://www.bittorrent.org/beps/bep_0048.html)
-#[derive(Debug, PartialEq, Default)]
+#[derive(Copy, Clone, Debug, PartialEq, Default, Constructor)]
 pub struct SwarmMetadata {
-    /// The number of peers that have ever completed downloading
-    pub downloaded: u32,
-    /// The number of active peers that have completed downloading (seeders)
-    pub complete: u32,
-    /// The number of active peers that have not completed downloading (leechers)
+    /// (i.e `completed`): The number of peers that have ever completed downloading
+    pub downloaded: u32, //
+    /// (i.e `seeders`): The number of active peers that have completed downloading (seeders)
+    pub complete: u32, //seeders
+    /// (i.e `leechers`): The number of active peers that have not completed downloading (leechers)
     pub incomplete: u32,
 }
 

src/core/torrent/mod.rs

@@ -152,7 +152,7 @@
 //! 000000f0: 65                                       e
 //! ```
 //!
-//! Refer to the [`Normal`](crate::servers::http::v1::responses::announce::Normal)
+//! Refer to the [`Normal`](crate::servers::http::v1::responses::announce::Normal), i.e. `Non-Compact`
 //! response for more information about the response.
 //!
 //! **Sample compact response**

src/servers/http/mod.rs

@@ -22,7 +22,7 @@ use crate::servers::http::v1::extractors::authentication_key::Extract as Extract
 use crate::servers::http::v1::extractors::client_ip_sources::Extract as ExtractClientIpSources;
 use crate::servers::http::v1::handlers::common::auth;
 use crate::servers::http::v1::requests::announce::{Announce, Compact, Event};
-use crate::servers::http::v1::responses::{self, announce};
+use crate::servers::http::v1::responses::{self};
 use crate::servers::http::v1::services::peer_ip_resolver::ClientIpSources;
 use crate::servers::http::v1::services::{self, peer_ip_resolver};
 use crate::shared::clock::{Current, Time};
@@ -117,13 +117,12 @@ async fn handle_announce(
 }
 
 fn build_response(announce_request: &Announce, announce_data: AnnounceData) -> Response {
-    match &announce_request.compact {
-        Some(compact) => match compact {
-            Compact::Accepted => announce::Compact::from(announce_data).into_response(),
-            Compact::NotAccepted => announce::Normal::from(announce_data).into_response(),
-        },
-        // Default response format non compact
-        None => announce::Normal::from(announce_data).into_response(),
+    if announce_request.compact.as_ref().is_some_and(|f| *f == Compact::Accepted) {
+        let response: responses::Announce<responses::Compact> = announce_data.into();
+        response.into_response()
+    } else {
+        let response: responses::Announce<responses::Normal> = announce_data.into();
+        response.into_response()
     }
 }
 

src/servers/http/v1/handlers/announce.rs

@@ -180,7 +180,7 @@ impl fmt::Display for Event {
 /// Depending on the value of this param, the tracker will return a different
 /// response:
 ///
-/// - [`Normal`](crate::servers::http::v1::responses::announce::Normal) response.
+/// - [`Normal`](crate::servers::http::v1::responses::announce::Normal), i.e. a `non-compact` response.
 /// - [`Compact`](crate::servers::http::v1::responses::announce::Compact) response.
 ///
 /// Refer to [BEP 23. Tracker Returns Compact Peer Lists](https://www.bittorrent.org/beps/bep_0023.html)