refactor: [torrust#1491] rename main types in torrent-repository pkg

josecelano · josecelano · commit df005336859e · 2025-05-01T18:32:13.000+01:00
diff --git a/packages/torrent-repository/src/entry/mod.rs b/packages/torrent-repository/src/entry/mod.rs
@@ -1,6 +1,2 @@
 pub mod peer_list;
 pub mod torrent;
-
-use std::sync::{Arc, Mutex};
-
-pub type TorrentEntry = Arc<Mutex<torrent::Torrent>>;
diff --git a/packages/torrent-repository/src/entry/torrent.rs b/packages/torrent-repository/src/entry/torrent.rs
@@ -16,15 +16,15 @@ use super::peer_list::PeerList;
 /// that's the list of all the peers trying to download the same torrent.
 /// The tracker keeps one entry like this for every torrent.
 #[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Torrent {
+pub struct TrackedTorrent {
     /// A network of peers that are all trying to download the torrent associated to this entry
     pub(crate) swarm: PeerList,
 
     /// The number of peers that have ever completed downloading the torrent associated to this entry
     pub(crate) downloaded: u32,
 }
 
-impl Torrent {
+impl TrackedTorrent {
     #[allow(clippy::cast_possible_truncation)]
     #[must_use]
     pub fn get_swarm_metadata(&self) -> SwarmMetadata {
diff --git a/packages/torrent-repository/src/lib.rs b/packages/torrent-repository/src/lib.rs
@@ -1,11 +1,13 @@
 pub mod entry;
 pub mod repository;
 
+use std::sync::{Arc, Mutex};
+
 use torrust_tracker_clock::clock;
 
-pub type TorrentEntry = entry::TorrentEntry;
-pub type Torrent = entry::torrent::Torrent;
-pub type Torrents = repository::TorrentsSkipMapMutexStd;
+pub type TorrentRepository = repository::TorrentRepository;
+pub type TrackedTorrentHandle = Arc<Mutex<TrackedTorrent>>;
+pub type TrackedTorrent = entry::torrent::TrackedTorrent;
 
 /// Working version, for production.
 #[cfg(not(test))]
diff --git a/packages/torrent-repository/src/repository.rs b/packages/torrent-repository/src/repository.rs
@@ -6,15 +6,15 @@ use torrust_tracker_primitives::swarm_metadata::{AggregateSwarmMetadata, SwarmMe
 use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch, PersistentTorrent, PersistentTorrents};
 
 use crate::entry::peer_list::PeerList;
-use crate::entry::torrent::Torrent;
-use crate::TorrentEntry;
+use crate::entry::torrent::TrackedTorrent;
+use crate::TrackedTorrentHandle;
 
 #[derive(Default, Debug)]
-pub struct TorrentsSkipMapMutexStd {
-    pub torrents: SkipMap<InfoHash, TorrentEntry>,
+pub struct TorrentRepository {
+    pub torrents: SkipMap<InfoHash, TrackedTorrentHandle>,
 }
 
-impl TorrentsSkipMapMutexStd {
+impl TorrentRepository {
     /// Upsert a peer into the swarm of a torrent.
     ///
     /// Optionally, it can also preset the number of downloads of the torrent
@@ -53,15 +53,15 @@ impl TorrentsSkipMapMutexStd {
             tracing::debug!("Inserting new torrent: {:?}", info_hash);
 
             let new_entry = if let Some(number_of_downloads) = opt_persistent_torrent {
-                TorrentEntry::new(
-                    Torrent {
+                TrackedTorrentHandle::new(
+                    TrackedTorrent {
                         swarm: PeerList::default(),
                         downloaded: number_of_downloads,
                     }
                     .into(),
                 )
             } else {
-                TorrentEntry::default()
+                TrackedTorrentHandle::default()
             };
 
             let inserted_entry = self.torrents.get_or_insert(*info_hash, new_entry);
@@ -85,7 +85,7 @@ impl TorrentsSkipMapMutexStd {
         })
     }
 
-    pub fn get(&self, key: &InfoHash) -> Option<TorrentEntry> {
+    pub fn get(&self, key: &InfoHash) -> Option<TrackedTorrentHandle> {
         let maybe_entry = self.torrents.get(key);
         maybe_entry.map(|entry| entry.value().clone())
     }
@@ -107,7 +107,7 @@ impl TorrentsSkipMapMutexStd {
         metrics
     }
 
-    pub fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, TorrentEntry)> {
+    pub fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, TrackedTorrentHandle)> {
         match pagination {
             Some(pagination) => self
                 .torrents
@@ -130,8 +130,8 @@ impl TorrentsSkipMapMutexStd {
                 continue;
             }
 
-            let entry = TorrentEntry::new(
-                Torrent {
+            let entry = TrackedTorrentHandle::new(
+                TrackedTorrent {
                     swarm: PeerList::default(),
                     downloaded: *completed,
                 }
@@ -144,7 +144,7 @@ impl TorrentsSkipMapMutexStd {
         }
     }
 
-    pub fn remove(&self, key: &InfoHash) -> Option<TorrentEntry> {
+    pub fn remove(&self, key: &InfoHash) -> Option<TrackedTorrentHandle> {
         self.torrents.remove(key).map(|entry| entry.value().clone())
     }
 
diff --git a/packages/torrent-repository/tests/common/repo.rs b/packages/torrent-repository/tests/common/repo.rs
@@ -5,12 +5,12 @@ use torrust_tracker_configuration::TrackerPolicy;
 use torrust_tracker_primitives::pagination::Pagination;
 use torrust_tracker_primitives::swarm_metadata::{AggregateSwarmMetadata, SwarmMetadata};
 use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch, PersistentTorrent, PersistentTorrents};
-use torrust_tracker_torrent_repository::entry::torrent::Torrent;
-use torrust_tracker_torrent_repository::Torrents;
+use torrust_tracker_torrent_repository::entry::torrent::TrackedTorrent;
+use torrust_tracker_torrent_repository::TorrentRepository;
 
 #[derive(Debug)]
 pub(crate) enum Repo {
-    SkipMapMutexStd(Torrents),
+    SkipMapMutexStd(TorrentRepository),
 }
 
 impl Repo {
@@ -31,7 +31,7 @@ impl Repo {
         }
     }
 
-    pub(crate) fn get(&self, key: &InfoHash) -> Option<Torrent> {
+    pub(crate) fn get(&self, key: &InfoHash) -> Option<TrackedTorrent> {
         match self {
             Repo::SkipMapMutexStd(repo) => Some(repo.get(key)?.lock().unwrap().clone()),
         }
@@ -43,7 +43,7 @@ impl Repo {
         }
     }
 
-    pub(crate) fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, Torrent)> {
+    pub(crate) fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, TrackedTorrent)> {
         match self {
             Repo::SkipMapMutexStd(repo) => repo
                 .get_paginated(pagination)
@@ -59,7 +59,7 @@ impl Repo {
         }
     }
 
-    pub(crate) fn remove(&self, key: &InfoHash) -> Option<Torrent> {
+    pub(crate) fn remove(&self, key: &InfoHash) -> Option<TrackedTorrent> {
         match self {
             Repo::SkipMapMutexStd(repo) => Some(repo.remove(key)?.lock().unwrap().clone()),
         }
@@ -77,7 +77,7 @@ impl Repo {
         }
     }
 
-    pub(crate) fn insert(&self, info_hash: &InfoHash, torrent: Torrent) -> Option<Torrent> {
+    pub(crate) fn insert(&self, info_hash: &InfoHash, torrent: TrackedTorrent) -> Option<TrackedTorrent> {
         match self {
             Repo::SkipMapMutexStd(repo) => {
                 repo.torrents.insert(*info_hash, Arc::new(Mutex::new(torrent)));
diff --git a/packages/torrent-repository/tests/common/torrent.rs b/packages/torrent-repository/tests/common/torrent.rs
@@ -4,12 +4,12 @@ use std::sync::Arc;
 use torrust_tracker_configuration::TrackerPolicy;
 use torrust_tracker_primitives::swarm_metadata::SwarmMetadata;
 use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch};
-use torrust_tracker_torrent_repository::{entry, TorrentEntry};
+use torrust_tracker_torrent_repository::{entry, TrackedTorrentHandle};
 
 #[derive(Debug, Clone)]
 pub(crate) enum Torrent {
-    Single(entry::torrent::Torrent),
-    MutexStd(TorrentEntry),
+    Single(entry::torrent::TrackedTorrent),
+    MutexStd(TrackedTorrentHandle),
 }
 
 impl Torrent {
diff --git a/packages/torrent-repository/tests/entry/mod.rs b/packages/torrent-repository/tests/entry/mod.rs
@@ -9,19 +9,19 @@ use torrust_tracker_clock::clock::{self, Time as _};
 use torrust_tracker_configuration::{TrackerPolicy, TORRENT_PEERS_LIMIT};
 use torrust_tracker_primitives::peer;
 use torrust_tracker_primitives::peer::Peer;
-use torrust_tracker_torrent_repository::{entry, TorrentEntry};
+use torrust_tracker_torrent_repository::{entry, TrackedTorrentHandle};
 
 use crate::common::torrent::Torrent;
 use crate::common::torrent_peer_builder::{a_completed_peer, a_started_peer};
 use crate::CurrentClock;
 
 #[fixture]
 fn single() -> Torrent {
-    Torrent::Single(entry::torrent::Torrent::default())
+    Torrent::Single(entry::torrent::TrackedTorrent::default())
 }
 #[fixture]
 fn mutex_std() -> Torrent {
-    Torrent::MutexStd(TorrentEntry::default())
+    Torrent::MutexStd(TrackedTorrentHandle::default())
 }
 
 #[fixture]
diff --git a/packages/torrent-repository/tests/repository/mod.rs b/packages/torrent-repository/tests/repository/mod.rs
@@ -8,18 +8,18 @@ use torrust_tracker_configuration::TrackerPolicy;
 use torrust_tracker_primitives::pagination::Pagination;
 use torrust_tracker_primitives::swarm_metadata::SwarmMetadata;
 use torrust_tracker_primitives::PersistentTorrents;
-use torrust_tracker_torrent_repository::entry::torrent::Torrent;
-use torrust_tracker_torrent_repository::Torrents;
+use torrust_tracker_torrent_repository::entry::torrent::TrackedTorrent;
+use torrust_tracker_torrent_repository::TorrentRepository;
 
 use crate::common::repo::Repo;
 use crate::common::torrent_peer_builder::{a_completed_peer, a_started_peer};
 
 #[fixture]
 fn skip_list_mutex_std() -> Repo {
-    Repo::SkipMapMutexStd(Torrents::default())
+    Repo::SkipMapMutexStd(TorrentRepository::default())
 }
 
-type Entries = Vec<(InfoHash, Torrent)>;
+type Entries = Vec<(InfoHash, TrackedTorrent)>;
 
 #[fixture]
 fn empty() -> Entries {
@@ -28,26 +28,26 @@ fn empty() -> Entries {
 
 #[fixture]
 fn default() -> Entries {
-    vec![(InfoHash::default(), Torrent::default())]
+    vec![(InfoHash::default(), TrackedTorrent::default())]
 }
 
 #[fixture]
 fn started() -> Entries {
-    let mut torrent = Torrent::default();
+    let mut torrent = TrackedTorrent::default();
     torrent.upsert_peer(&a_started_peer(1));
     vec![(InfoHash::default(), torrent)]
 }
 
 #[fixture]
 fn completed() -> Entries {
-    let mut torrent = Torrent::default();
+    let mut torrent = TrackedTorrent::default();
     torrent.upsert_peer(&a_completed_peer(2));
     vec![(InfoHash::default(), torrent)]
 }
 
 #[fixture]
 fn downloaded() -> Entries {
-    let mut torrent = Torrent::default();
+    let mut torrent = TrackedTorrent::default();
     let mut peer = a_started_peer(3);
     torrent.upsert_peer(&peer);
     peer.event = AnnounceEvent::Completed;
@@ -58,17 +58,17 @@ fn downloaded() -> Entries {
 
 #[fixture]
 fn three() -> Entries {
-    let mut started = Torrent::default();
+    let mut started = TrackedTorrent::default();
     let started_h = &mut DefaultHasher::default();
     started.upsert_peer(&a_started_peer(1));
     started.hash(started_h);
 
-    let mut completed = Torrent::default();
+    let mut completed = TrackedTorrent::default();
     let completed_h = &mut DefaultHasher::default();
     completed.upsert_peer(&a_completed_peer(2));
     completed.hash(completed_h);
 
-    let mut downloaded = Torrent::default();
+    let mut downloaded = TrackedTorrent::default();
     let downloaded_h = &mut DefaultHasher::default();
     let mut downloaded_peer = a_started_peer(3);
     downloaded.upsert_peer(&downloaded_peer);
@@ -86,10 +86,10 @@ fn three() -> Entries {
 
 #[fixture]
 fn many_out_of_order() -> Entries {
-    let mut entries: HashSet<(InfoHash, Torrent)> = HashSet::default();
+    let mut entries: HashSet<(InfoHash, TrackedTorrent)> = HashSet::default();
 
     for i in 0..408 {
-        let mut entry = Torrent::default();
+        let mut entry = TrackedTorrent::default();
         entry.upsert_peer(&a_started_peer(i));
 
         entries.insert((InfoHash::from(&i), entry));
@@ -101,10 +101,10 @@ fn many_out_of_order() -> Entries {
 
 #[fixture]
 fn many_hashed_in_order() -> Entries {
-    let mut entries: BTreeMap<InfoHash, Torrent> = BTreeMap::default();
+    let mut entries: BTreeMap<InfoHash, TrackedTorrent> = BTreeMap::default();
 
     for i in 0..408 {
-        let mut entry = Torrent::default();
+        let mut entry = TrackedTorrent::default();
         entry.upsert_peer(&a_started_peer(i));
 
         let hash: &mut DefaultHasher = &mut DefaultHasher::default();
diff --git a/packages/tracker-core/src/torrent/repository/in_memory.rs b/packages/tracker-core/src/torrent/repository/in_memory.rs
@@ -7,7 +7,7 @@ use torrust_tracker_configuration::{TrackerPolicy, TORRENT_PEERS_LIMIT};
 use torrust_tracker_primitives::pagination::Pagination;
 use torrust_tracker_primitives::swarm_metadata::{AggregateSwarmMetadata, SwarmMetadata};
 use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch, PersistentTorrent, PersistentTorrents};
-use torrust_tracker_torrent_repository::{TorrentEntry, Torrents};
+use torrust_tracker_torrent_repository::{TorrentRepository, TrackedTorrentHandle};
 
 /// In-memory repository for torrent entries.
 ///
@@ -21,7 +21,7 @@ use torrust_tracker_torrent_repository::{TorrentEntry, Torrents};
 #[derive(Debug, Default)]
 pub struct InMemoryTorrentRepository {
     /// The underlying in-memory data structure that stores torrent entries.
-    torrents: Arc<Torrents>,
+    torrents: Arc<TorrentRepository>,
 }
 
 impl InMemoryTorrentRepository {
@@ -64,7 +64,7 @@ impl InMemoryTorrentRepository {
     /// An `Option` containing the removed torrent entry if it existed.
     #[cfg(test)]
     #[must_use]
-    pub(crate) fn remove(&self, key: &InfoHash) -> Option<TorrentEntry> {
+    pub(crate) fn remove(&self, key: &InfoHash) -> Option<TrackedTorrentHandle> {
         self.torrents.remove(key)
     }
 
@@ -104,7 +104,7 @@ impl InMemoryTorrentRepository {
     ///
     /// An `Option` containing the torrent entry if found.
     #[must_use]
-    pub(crate) fn get(&self, key: &InfoHash) -> Option<TorrentEntry> {
+    pub(crate) fn get(&self, key: &InfoHash) -> Option<TrackedTorrentHandle> {
         self.torrents.get(key)
     }
 
@@ -122,7 +122,7 @@ impl InMemoryTorrentRepository {
     ///
     /// A vector of `(InfoHash, TorrentEntry)` tuples.
     #[must_use]
-    pub(crate) fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, TorrentEntry)> {
+    pub(crate) fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, TrackedTorrentHandle)> {
         self.torrents.get_paginated(pagination)
     }
 
@@ -510,7 +510,7 @@ mod tests {
 
             use torrust_tracker_primitives::peer::Peer;
             use torrust_tracker_primitives::swarm_metadata::SwarmMetadata;
-            use torrust_tracker_torrent_repository::TorrentEntry;
+            use torrust_tracker_torrent_repository::TrackedTorrentHandle;
 
             use crate::test_helpers::tests::{sample_info_hash, sample_peer};
             use crate::torrent::repository::in_memory::InMemoryTorrentRepository;
@@ -526,7 +526,7 @@ mod tests {
             }
 
             #[allow(clippy::from_over_into)]
-            impl Into<TorrentEntryInfo> for TorrentEntry {
+            impl Into<TorrentEntryInfo> for TrackedTorrentHandle {
                 fn into(self) -> TorrentEntryInfo {
                     let torrent_guard = self.lock().expect("can't acquire lock for torrent entry");
 

Original file line number	Diff line number	Diff line change
`@@ -5,12 +5,12 @@ use torrust_tracker_configuration::TrackerPolicy;`
`5`	`5`	`use torrust_tracker_primitives::pagination::Pagination;`
`6`	`6`	`use torrust_tracker_primitives::swarm_metadata::{AggregateSwarmMetadata, SwarmMetadata};`
`7`	`7`	`use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch, PersistentTorrent, PersistentTorrents};`
`8`		`-use torrust_tracker_torrent_repository::entry::torrent::Torrent;`
`9`		`-use torrust_tracker_torrent_repository::Torrents;`
	`8`	`+use torrust_tracker_torrent_repository::entry::torrent::TrackedTorrent;`
	`9`	`+use torrust_tracker_torrent_repository::TorrentRepository;`
`10`	`10`
`11`	`11`	`#[derive(Debug)]`
`12`	`12`	`pub(crate) enum Repo {`
`13`		`- SkipMapMutexStd(Torrents),`
	`13`	`+ SkipMapMutexStd(TorrentRepository),`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`impl Repo {`
`@@ -31,7 +31,7 @@ impl Repo {`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`
`34`		`- pub(crate) fn get(&self, key: &InfoHash) -> Option<Torrent> {`
	`34`	`+ pub(crate) fn get(&self, key: &InfoHash) -> Option<TrackedTorrent> {`
`35`	`35`	`match self {`
`36`	`36`	`Repo::SkipMapMutexStd(repo) => Some(repo.get(key)?.lock().unwrap().clone()),`
`37`	`37`	`}`
`@@ -43,7 +43,7 @@ impl Repo {`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`
`46`		`- pub(crate) fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, Torrent)> {`
	`46`	`+ pub(crate) fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, TrackedTorrent)> {`
`47`	`47`	`match self {`
`48`	`48`	`Repo::SkipMapMutexStd(repo) => repo`
`49`	`49`	`.get_paginated(pagination)`
`@@ -59,7 +59,7 @@ impl Repo {`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`
`62`		`- pub(crate) fn remove(&self, key: &InfoHash) -> Option<Torrent> {`
	`62`	`+ pub(crate) fn remove(&self, key: &InfoHash) -> Option<TrackedTorrent> {`
`63`	`63`	`match self {`
`64`	`64`	`Repo::SkipMapMutexStd(repo) => Some(repo.remove(key)?.lock().unwrap().clone()),`
`65`	`65`	`}`
`@@ -77,7 +77,7 @@ impl Repo {`
`77`	`77`	`}`
`78`	`78`	`}`
`79`	`79`
`80`		`- pub(crate) fn insert(&self, info_hash: &InfoHash, torrent: Torrent) -> Option<Torrent> {`
	`80`	`+ pub(crate) fn insert(&self, info_hash: &InfoHash, torrent: TrackedTorrent) -> Option<TrackedTorrent> {`
`81`	`81`	`match self {`
`82`	`82`	`Repo::SkipMapMutexStd(repo) => {`
`83`	`83`	`repo.torrents.insert(*info_hash, Arc::new(Mutex::new(torrent)));`