dev: refactor torrent entry defs

da2ce7 · da2ce7 · commit fe80703b6177 · 2024-03-16T04:05:38.000+08:00
diff --git a/packages/torrent-repository/src/entry.rs b/packages/torrent-repository/src/entry.rs
@@ -8,6 +8,8 @@ use torrust_tracker_primitives::peer::ReadInfo as _;
 use torrust_tracker_primitives::swarm_metadata::SwarmMetadata;
 use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch};
 
+use crate::{EntryMutexStd, EntryMutexTokio, EntrySingle};
+
 /// A data structure containing all the information about a torrent in the tracker.
 ///
 /// This is the tracker entry for a given torrent and contains the swarm data,
@@ -21,9 +23,6 @@ pub struct Entry {
     /// The number of peers that have ever completed downloading the torrent associated to this entry
     pub(crate) completed: u32,
 }
-pub type Single = Entry;
-pub type MutexStd = Arc<std::sync::Mutex<Entry>>;
-pub type MutexTokio = Arc<tokio::sync::Mutex<Entry>>;
 
 pub trait ReadInfo {
     /// It returns the swarm metadata (statistics) as a struct:
@@ -115,7 +114,7 @@ pub trait UpdateAsync {
     fn remove_inactive_peers(self, current_cutoff: DurationSinceUnixEpoch) -> impl std::future::Future<Output = ()> + Send;
 }
 
-impl ReadInfo for Single {
+impl ReadInfo for EntrySingle {
     #[allow(clippy::cast_possible_truncation)]
     fn get_stats(&self) -> SwarmMetadata {
         let complete: u32 = self.peers.values().filter(|peer| peer.is_seeder()).count() as u32;
@@ -149,7 +148,7 @@ impl ReadInfo for Single {
     }
 }
 
-impl ReadInfo for MutexStd {
+impl ReadInfo for EntryMutexStd {
     fn get_stats(&self) -> SwarmMetadata {
         self.lock().expect("it should get a lock").get_stats()
     }
@@ -167,7 +166,7 @@ impl ReadInfo for MutexStd {
     }
 }
 
-impl ReadInfoAsync for MutexTokio {
+impl ReadInfoAsync for EntryMutexTokio {
     async fn get_stats(self) -> SwarmMetadata {
         self.lock().await.get_stats()
     }
@@ -185,7 +184,7 @@ impl ReadInfoAsync for MutexTokio {
     }
 }
 
-impl ReadPeers for Single {
+impl ReadPeers for EntrySingle {
     fn get_peers(&self, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {
         match limit {
             Some(limit) => self.peers.values().take(limit).cloned().collect(),
@@ -215,7 +214,7 @@ impl ReadPeers for Single {
     }
 }
 
-impl ReadPeers for MutexStd {
+impl ReadPeers for EntryMutexStd {
     fn get_peers(&self, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {
         self.lock().expect("it should get lock").get_peers(limit)
     }
@@ -225,7 +224,7 @@ impl ReadPeers for MutexStd {
     }
 }
 
-impl ReadPeersAsync for MutexTokio {
+impl ReadPeersAsync for EntryMutexTokio {
     async fn get_peers(self, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {
         self.lock().await.get_peers(limit)
     }
@@ -235,7 +234,7 @@ impl ReadPeersAsync for MutexTokio {
     }
 }
 
-impl Update for Single {
+impl Update for EntrySingle {
     fn insert_or_update_peer(&mut self, peer: &peer::Peer) -> bool {
         let mut did_torrent_stats_change: bool = false;
 
@@ -270,7 +269,7 @@ impl Update for Single {
     }
 }
 
-impl UpdateSync for MutexStd {
+impl UpdateSync for EntryMutexStd {
     fn insert_or_update_peer(&self, peer: &peer::Peer) -> bool {
         self.lock().expect("it should lock the entry").insert_or_update_peer(peer)
     }
@@ -288,7 +287,7 @@ impl UpdateSync for MutexStd {
     }
 }
 
-impl UpdateAsync for MutexTokio {
+impl UpdateAsync for EntryMutexTokio {
     async fn insert_or_update_peer(self, peer: &peer::Peer) -> bool {
         self.lock().await.insert_or_update_peer(peer)
     }
diff --git a/packages/torrent-repository/src/lib.rs b/packages/torrent-repository/src/lib.rs
@@ -1,9 +1,15 @@
+use std::sync::Arc;
+
 pub mod entry;
 pub mod repository;
 
-pub type TorrentsRwLockStd = repository::RwLockStd<entry::Single>;
-pub type TorrentsRwLockStdMutexStd = repository::RwLockStd<entry::MutexStd>;
-pub type TorrentsRwLockStdMutexTokio = repository::RwLockStd<entry::MutexTokio>;
-pub type TorrentsRwLockTokio = repository::RwLockTokio<entry::Single>;
-pub type TorrentsRwLockTokioMutexStd = repository::RwLockTokio<entry::MutexStd>;
-pub type TorrentsRwLockTokioMutexTokio = repository::RwLockTokio<entry::MutexTokio>;
+pub type EntrySingle = entry::Entry;
+pub type EntryMutexStd = Arc<std::sync::Mutex<entry::Entry>>;
+pub type EntryMutexTokio = Arc<tokio::sync::Mutex<entry::Entry>>;
+
+pub type TorrentsRwLockStd = repository::RwLockStd<EntrySingle>;
+pub type TorrentsRwLockStdMutexStd = repository::RwLockStd<EntryMutexStd>;
+pub type TorrentsRwLockStdMutexTokio = repository::RwLockStd<EntryMutexTokio>;
+pub type TorrentsRwLockTokio = repository::RwLockTokio<EntrySingle>;
+pub type TorrentsRwLockTokioMutexStd = repository::RwLockTokio<EntryMutexStd>;
+pub type TorrentsRwLockTokioMutexTokio = repository::RwLockTokio<EntryMutexTokio>;
diff --git a/packages/torrent-repository/src/repository/rw_lock_std.rs b/packages/torrent-repository/src/repository/rw_lock_std.rs
@@ -9,20 +9,20 @@ use torrust_tracker_primitives::torrent_metrics::TorrentsMetrics;
 use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch, PersistentTorrents};
 
 use super::{Repository, UpdateTorrentSync};
-use crate::entry::{self, ReadInfo, Update};
-use crate::TorrentsRwLockStd;
+use crate::entry::{ReadInfo, Update};
+use crate::{EntrySingle, TorrentsRwLockStd};
 
 impl TorrentsRwLockStd {
-    fn get_torrents<'a>(&'a self) -> std::sync::RwLockReadGuard<'a, std::collections::BTreeMap<InfoHash, entry::Single>>
+    fn get_torrents<'a>(&'a self) -> std::sync::RwLockReadGuard<'a, std::collections::BTreeMap<InfoHash, EntrySingle>>
     where
-        std::collections::BTreeMap<InfoHash, entry::Single>: 'a,
+        std::collections::BTreeMap<InfoHash, EntrySingle>: 'a,
     {
         self.torrents.read().expect("it should get the read lock")
     }
 
-    fn get_torrents_mut<'a>(&'a self) -> std::sync::RwLockWriteGuard<'a, std::collections::BTreeMap<InfoHash, entry::Single>>
+    fn get_torrents_mut<'a>(&'a self) -> std::sync::RwLockWriteGuard<'a, std::collections::BTreeMap<InfoHash, EntrySingle>>
     where
-        std::collections::BTreeMap<InfoHash, entry::Single>: 'a,
+        std::collections::BTreeMap<InfoHash, EntrySingle>: 'a,
     {
         self.torrents.write().expect("it should get the write lock")
     }
@@ -32,7 +32,7 @@ impl UpdateTorrentSync for TorrentsRwLockStd {
     fn update_torrent_with_peer_and_get_stats(&self, info_hash: &InfoHash, peer: &peer::Peer) -> (bool, SwarmMetadata) {
         let mut db = self.get_torrents_mut();
 
-        let entry = db.entry(*info_hash).or_insert(entry::Single::default());
+        let entry = db.entry(*info_hash).or_insert(EntrySingle::default());
 
         entry.insert_or_update_peer_and_get_stats(peer)
     }
@@ -44,8 +44,8 @@ impl UpdateTorrentSync for Arc<TorrentsRwLockStd> {
     }
 }
 
-impl Repository<entry::Single> for TorrentsRwLockStd {
-    async fn get(&self, key: &InfoHash) -> Option<entry::Single> {
+impl Repository<EntrySingle> for TorrentsRwLockStd {
+    async fn get(&self, key: &InfoHash) -> Option<EntrySingle> {
         let db = self.get_torrents();
         db.get(key).cloned()
     }
@@ -64,7 +64,7 @@ impl Repository<entry::Single> for TorrentsRwLockStd {
         metrics
     }
 
-    async fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, entry::Single)> {
+    async fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, EntrySingle)> {
         let db = self.get_torrents();
 
         match pagination {
@@ -87,7 +87,7 @@ impl Repository<entry::Single> for TorrentsRwLockStd {
                 continue;
             }
 
-            let entry = entry::Single {
+            let entry = EntrySingle {
                 peers: BTreeMap::default(),
                 completed: *completed,
             };
@@ -96,7 +96,7 @@ impl Repository<entry::Single> for TorrentsRwLockStd {
         }
     }
 
-    async fn remove(&self, key: &InfoHash) -> Option<entry::Single> {
+    async fn remove(&self, key: &InfoHash) -> Option<EntrySingle> {
         let mut db = self.get_torrents_mut();
         db.remove(key)
     }
diff --git a/packages/torrent-repository/src/repository/rw_lock_std_mutex_std.rs b/packages/torrent-repository/src/repository/rw_lock_std_mutex_std.rs
@@ -9,20 +9,20 @@ use torrust_tracker_primitives::torrent_metrics::TorrentsMetrics;
 use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch, PersistentTorrents};
 
 use super::{Repository, UpdateTorrentSync};
-use crate::entry::{self, ReadInfo, UpdateSync};
-use crate::TorrentsRwLockStdMutexStd;
+use crate::entry::{ReadInfo, UpdateSync};
+use crate::{EntryMutexStd, EntrySingle, TorrentsRwLockStdMutexStd};
 
 impl TorrentsRwLockStdMutexStd {
-    fn get_torrents<'a>(&'a self) -> std::sync::RwLockReadGuard<'a, std::collections::BTreeMap<InfoHash, entry::MutexStd>>
+    fn get_torrents<'a>(&'a self) -> std::sync::RwLockReadGuard<'a, std::collections::BTreeMap<InfoHash, EntryMutexStd>>
     where
-        std::collections::BTreeMap<InfoHash, entry::MutexStd>: 'a,
+        std::collections::BTreeMap<InfoHash, crate::EntryMutexStd>: 'a,
     {
         self.torrents.read().expect("unable to get torrent list")
     }
 
-    fn get_torrents_mut<'a>(&'a self) -> std::sync::RwLockWriteGuard<'a, std::collections::BTreeMap<InfoHash, entry::MutexStd>>
+    fn get_torrents_mut<'a>(&'a self) -> std::sync::RwLockWriteGuard<'a, std::collections::BTreeMap<InfoHash, EntryMutexStd>>
     where
-        std::collections::BTreeMap<InfoHash, entry::MutexStd>: 'a,
+        std::collections::BTreeMap<InfoHash, EntryMutexStd>: 'a,
     {
         self.torrents.write().expect("unable to get writable torrent list")
     }
@@ -50,8 +50,8 @@ impl UpdateTorrentSync for Arc<TorrentsRwLockStdMutexStd> {
     }
 }
 
-impl Repository<entry::MutexStd> for TorrentsRwLockStdMutexStd {
-    async fn get(&self, key: &InfoHash) -> Option<entry::MutexStd> {
+impl Repository<EntryMutexStd> for TorrentsRwLockStdMutexStd {
+    async fn get(&self, key: &InfoHash) -> Option<EntryMutexStd> {
         let db = self.get_torrents();
         db.get(key).cloned()
     }
@@ -70,7 +70,7 @@ impl Repository<entry::MutexStd> for TorrentsRwLockStdMutexStd {
         metrics
     }
 
-    async fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, entry::MutexStd)> {
+    async fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, EntryMutexStd)> {
         let db = self.get_torrents();
 
         match pagination {
@@ -93,8 +93,8 @@ impl Repository<entry::MutexStd> for TorrentsRwLockStdMutexStd {
                 continue;
             }
 
-            let entry = entry::MutexStd::new(
-                entry::Single {
+            let entry = EntryMutexStd::new(
+                EntrySingle {
                     peers: BTreeMap::default(),
                     completed: *completed,
                 }
@@ -105,7 +105,7 @@ impl Repository<entry::MutexStd> for TorrentsRwLockStdMutexStd {
         }
     }
 
-    async fn remove(&self, key: &InfoHash) -> Option<entry::MutexStd> {
+    async fn remove(&self, key: &InfoHash) -> Option<EntryMutexStd> {
         let mut db = self.get_torrents_mut();
         db.remove(key)
     }
diff --git a/packages/torrent-repository/src/repository/rw_lock_std_mutex_tokio.rs b/packages/torrent-repository/src/repository/rw_lock_std_mutex_tokio.rs
@@ -13,19 +13,19 @@ use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch, PersistentTorrent
 
 use super::{Repository, UpdateTorrentAsync};
 use crate::entry::{self, ReadInfo, UpdateAsync};
-use crate::TorrentsRwLockStdMutexTokio;
+use crate::{EntryMutexTokio, EntrySingle, TorrentsRwLockStdMutexTokio};
 
 impl TorrentsRwLockStdMutexTokio {
-    fn get_torrents<'a>(&'a self) -> std::sync::RwLockReadGuard<'a, std::collections::BTreeMap<InfoHash, entry::MutexTokio>>
+    fn get_torrents<'a>(&'a self) -> std::sync::RwLockReadGuard<'a, std::collections::BTreeMap<InfoHash, EntryMutexTokio>>
     where
-        std::collections::BTreeMap<InfoHash, entry::MutexTokio>: 'a,
+        std::collections::BTreeMap<InfoHash, EntryMutexTokio>: 'a,
     {
         self.torrents.read().expect("unable to get torrent list")
     }
 
-    fn get_torrents_mut<'a>(&'a self) -> std::sync::RwLockWriteGuard<'a, std::collections::BTreeMap<InfoHash, entry::MutexTokio>>
+    fn get_torrents_mut<'a>(&'a self) -> std::sync::RwLockWriteGuard<'a, std::collections::BTreeMap<InfoHash, EntryMutexTokio>>
     where
-        std::collections::BTreeMap<InfoHash, entry::MutexTokio>: 'a,
+        std::collections::BTreeMap<InfoHash, EntryMutexTokio>: 'a,
     {
         self.torrents.write().expect("unable to get writable torrent list")
     }
@@ -53,13 +53,13 @@ impl UpdateTorrentAsync for Arc<TorrentsRwLockStdMutexTokio> {
     }
 }
 
-impl Repository<entry::MutexTokio> for TorrentsRwLockStdMutexTokio {
-    async fn get(&self, key: &InfoHash) -> Option<entry::MutexTokio> {
+impl Repository<EntryMutexTokio> for TorrentsRwLockStdMutexTokio {
+    async fn get(&self, key: &InfoHash) -> Option<EntryMutexTokio> {
         let db = self.get_torrents();
         db.get(key).cloned()
     }
 
-    async fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, entry::MutexTokio)> {
+    async fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, EntryMutexTokio)> {
         let db = self.get_torrents();
 
         match pagination {
@@ -98,8 +98,8 @@ impl Repository<entry::MutexTokio> for TorrentsRwLockStdMutexTokio {
                 continue;
             }
 
-            let entry = entry::MutexTokio::new(
-                entry::Single {
+            let entry = EntryMutexTokio::new(
+                EntrySingle {
                     peers: BTreeMap::default(),
                     completed: *completed,
                 }
@@ -110,7 +110,7 @@ impl Repository<entry::MutexTokio> for TorrentsRwLockStdMutexTokio {
         }
     }
 
-    async fn remove(&self, key: &InfoHash) -> Option<entry::MutexTokio> {
+    async fn remove(&self, key: &InfoHash) -> Option<EntryMutexTokio> {
         let mut db = self.get_torrents_mut();
         db.remove(key)
     }
diff --git a/packages/torrent-repository/src/repository/rw_lock_tokio.rs b/packages/torrent-repository/src/repository/rw_lock_tokio.rs
@@ -9,22 +9,22 @@ use torrust_tracker_primitives::torrent_metrics::TorrentsMetrics;
 use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch, PersistentTorrents};
 
 use super::{Repository, UpdateTorrentAsync};
-use crate::entry::{self, ReadInfo, Update};
-use crate::TorrentsRwLockTokio;
+use crate::entry::{ReadInfo, Update};
+use crate::{EntrySingle, TorrentsRwLockTokio};
 
 impl TorrentsRwLockTokio {
-    async fn get_torrents<'a>(&'a self) -> tokio::sync::RwLockReadGuard<'a, std::collections::BTreeMap<InfoHash, entry::Single>>
+    async fn get_torrents<'a>(&'a self) -> tokio::sync::RwLockReadGuard<'a, std::collections::BTreeMap<InfoHash, EntrySingle>>
     where
-        std::collections::BTreeMap<InfoHash, entry::Single>: 'a,
+        std::collections::BTreeMap<InfoHash, EntrySingle>: 'a,
     {
         self.torrents.read().await
     }
 
     async fn get_torrents_mut<'a>(
         &'a self,
-    ) -> tokio::sync::RwLockWriteGuard<'a, std::collections::BTreeMap<InfoHash, entry::Single>>
+    ) -> tokio::sync::RwLockWriteGuard<'a, std::collections::BTreeMap<InfoHash, EntrySingle>>
     where
-        std::collections::BTreeMap<InfoHash, entry::Single>: 'a,
+        std::collections::BTreeMap<InfoHash, EntrySingle>: 'a,
     {
         self.torrents.write().await
     }
@@ -34,7 +34,7 @@ impl UpdateTorrentAsync for TorrentsRwLockTokio {
     async fn update_torrent_with_peer_and_get_stats(&self, info_hash: &InfoHash, peer: &peer::Peer) -> (bool, SwarmMetadata) {
         let mut db = self.get_torrents_mut().await;
 
-        let entry = db.entry(*info_hash).or_insert(entry::Single::default());
+        let entry = db.entry(*info_hash).or_insert(EntrySingle::default());
 
         entry.insert_or_update_peer_and_get_stats(peer)
     }
@@ -46,13 +46,13 @@ impl UpdateTorrentAsync for Arc<TorrentsRwLockTokio> {
     }
 }
 
-impl Repository<entry::Single> for TorrentsRwLockTokio {
-    async fn get(&self, key: &InfoHash) -> Option<entry::Single> {
+impl Repository<EntrySingle> for TorrentsRwLockTokio {
+    async fn get(&self, key: &InfoHash) -> Option<EntrySingle> {
         let db = self.get_torrents().await;
         db.get(key).cloned()
     }
 
-    async fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, entry::Single)> {
+    async fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, EntrySingle)> {
         let db = self.get_torrents().await;
 
         match pagination {
@@ -89,7 +89,7 @@ impl Repository<entry::Single> for TorrentsRwLockTokio {
                 continue;
             }
 
-            let entry = entry::Single {
+            let entry = EntrySingle {
                 peers: BTreeMap::default(),
                 completed: *completed,
             };
@@ -98,7 +98,7 @@ impl Repository<entry::Single> for TorrentsRwLockTokio {
         }
     }
 
-    async fn remove(&self, key: &InfoHash) -> Option<entry::Single> {
+    async fn remove(&self, key: &InfoHash) -> Option<EntrySingle> {
         let mut db = self.get_torrents_mut().await;
         db.remove(key)
     }
diff --git a/packages/torrent-repository/src/repository/rw_lock_tokio_mutex_std.rs b/packages/torrent-repository/src/repository/rw_lock_tokio_mutex_std.rs
diff --git a/packages/torrent-repository/src/repository/rw_lock_tokio_mutex_tokio.rs b/packages/torrent-repository/src/repository/rw_lock_tokio_mutex_tokio.rs
diff --git a/src/core/torrent/mod.rs b/src/core/torrent/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,8 @@ use torrust_tracker_primitives::peer::ReadInfo as _;`
`8`	`8`	`use torrust_tracker_primitives::swarm_metadata::SwarmMetadata;`
`9`	`9`	`use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch};`
`10`	`10`
	`11`	`+use crate::{EntryMutexStd, EntryMutexTokio, EntrySingle};`
	`12`	`+`
`11`	`13`	`/// A data structure containing all the information about a torrent in the tracker.`
`12`	`14`	`///`
`13`	`15`	`/// This is the tracker entry for a given torrent and contains the swarm data,`
`@@ -21,9 +23,6 @@ pub struct Entry {`
`21`	`23`	`/// The number of peers that have ever completed downloading the torrent associated to this entry`
`22`	`24`	`pub(crate) completed: u32,`
`23`	`25`	`}`
`24`		`-pub type Single = Entry;`
`25`		`-pub type MutexStd = Arc<std::sync::Mutex<Entry>>;`
`26`		`-pub type MutexTokio = Arc<tokio::sync::Mutex<Entry>>;`
`27`	`26`
`28`	`27`	`pub trait ReadInfo {`
`29`	`28`	`/// It returns the swarm metadata (statistics) as a struct:`
`@@ -115,7 +114,7 @@ pub trait UpdateAsync {`
`115`	`114`	`fn remove_inactive_peers(self, current_cutoff: DurationSinceUnixEpoch) -> impl std::future::Future<Output = ()> + Send;`
`116`	`115`	`}`
`117`	`116`
`118`		`-impl ReadInfo for Single {`
	`117`	`+impl ReadInfo for EntrySingle {`
`119`	`118`	`#[allow(clippy::cast_possible_truncation)]`
`120`	`119`	`fn get_stats(&self) -> SwarmMetadata {`
`121`	`120`	`let complete: u32 = self.peers.values().filter(\|peer\| peer.is_seeder()).count() as u32;`
`@@ -149,7 +148,7 @@ impl ReadInfo for Single {`
`149`	`148`	`}`
`150`	`149`	`}`
`151`	`150`
`152`		`-impl ReadInfo for MutexStd {`
	`151`	`+impl ReadInfo for EntryMutexStd {`
`153`	`152`	`fn get_stats(&self) -> SwarmMetadata {`
`154`	`153`	`self.lock().expect("it should get a lock").get_stats()`
`155`	`154`	`}`
`@@ -167,7 +166,7 @@ impl ReadInfo for MutexStd {`
`167`	`166`	`}`
`168`	`167`	`}`
`169`	`168`
`170`		`-impl ReadInfoAsync for MutexTokio {`
	`169`	`+impl ReadInfoAsync for EntryMutexTokio {`
`171`	`170`	`async fn get_stats(self) -> SwarmMetadata {`
`172`	`171`	`self.lock().await.get_stats()`
`173`	`172`	`}`
`@@ -185,7 +184,7 @@ impl ReadInfoAsync for MutexTokio {`
`185`	`184`	`}`
`186`	`185`	`}`
`187`	`186`
`188`		`-impl ReadPeers for Single {`
	`187`	`+impl ReadPeers for EntrySingle {`
`189`	`188`	`fn get_peers(&self, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {`
`190`	`189`	`match limit {`
`191`	`190`	`Some(limit) => self.peers.values().take(limit).cloned().collect(),`
`@@ -215,7 +214,7 @@ impl ReadPeers for Single {`
`215`	`214`	`}`
`216`	`215`	`}`
`217`	`216`
`218`		`-impl ReadPeers for MutexStd {`
	`217`	`+impl ReadPeers for EntryMutexStd {`
`219`	`218`	`fn get_peers(&self, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {`
`220`	`219`	`self.lock().expect("it should get lock").get_peers(limit)`
`221`	`220`	`}`
`@@ -225,7 +224,7 @@ impl ReadPeers for MutexStd {`
`225`	`224`	`}`
`226`	`225`	`}`
`227`	`226`
`228`		`-impl ReadPeersAsync for MutexTokio {`
	`227`	`+impl ReadPeersAsync for EntryMutexTokio {`
`229`	`228`	`async fn get_peers(self, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {`
`230`	`229`	`self.lock().await.get_peers(limit)`
`231`	`230`	`}`
`@@ -235,7 +234,7 @@ impl ReadPeersAsync for MutexTokio {`
`235`	`234`	`}`
`236`	`235`	`}`
`237`	`236`
`238`		`-impl Update for Single {`
	`237`	`+impl Update for EntrySingle {`
`239`	`238`	`fn insert_or_update_peer(&mut self, peer: &peer::Peer) -> bool {`
`240`	`239`	`let mut did_torrent_stats_change: bool = false;`
`241`	`240`
`@@ -270,7 +269,7 @@ impl Update for Single {`
`270`	`269`	`}`
`271`	`270`	`}`
`272`	`271`
`273`		`-impl UpdateSync for MutexStd {`
	`272`	`+impl UpdateSync for EntryMutexStd {`
`274`	`273`	`fn insert_or_update_peer(&self, peer: &peer::Peer) -> bool {`
`275`	`274`	`self.lock().expect("it should lock the entry").insert_or_update_peer(peer)`
`276`	`275`	`}`
`@@ -288,7 +287,7 @@ impl UpdateSync for MutexStd {`
`288`	`287`	`}`
`289`	`288`	`}`
`290`	`289`
`291`		`-impl UpdateAsync for MutexTokio {`
	`290`	`+impl UpdateAsync for EntryMutexTokio {`
`292`	`291`	`async fn insert_or_update_peer(self, peer: &peer::Peer) -> bool {`
`293`	`292`	`self.lock().await.insert_or_update_peer(peer)`
`294`	`293`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,20 +9,20 @@ use torrust_tracker_primitives::torrent_metrics::TorrentsMetrics;`
`9`	`9`	`use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch, PersistentTorrents};`
`10`	`10`
`11`	`11`	`use super::{Repository, UpdateTorrentSync};`
`12`		`-use crate::entry::{self, ReadInfo, Update};`
`13`		`-use crate::TorrentsRwLockStd;`
	`12`	`+use crate::entry::{ReadInfo, Update};`
	`13`	`+use crate::{EntrySingle, TorrentsRwLockStd};`
`14`	`14`
`15`	`15`	`impl TorrentsRwLockStd {`
`16`		`- fn get_torrents<'a>(&'a self) -> std::sync::RwLockReadGuard<'a, std::collections::BTreeMap<InfoHash, entry::Single>>`
	`16`	`+ fn get_torrents<'a>(&'a self) -> std::sync::RwLockReadGuard<'a, std::collections::BTreeMap<InfoHash, EntrySingle>>`
`17`	`17`	`where`
`18`		`- std::collections::BTreeMap<InfoHash, entry::Single>: 'a,`
	`18`	`+ std::collections::BTreeMap<InfoHash, EntrySingle>: 'a,`
`19`	`19`	`{`
`20`	`20`	`self.torrents.read().expect("it should get the read lock")`
`21`	`21`	`}`
`22`	`22`
`23`		`- fn get_torrents_mut<'a>(&'a self) -> std::sync::RwLockWriteGuard<'a, std::collections::BTreeMap<InfoHash, entry::Single>>`
	`23`	`+ fn get_torrents_mut<'a>(&'a self) -> std::sync::RwLockWriteGuard<'a, std::collections::BTreeMap<InfoHash, EntrySingle>>`
`24`	`24`	`where`
`25`		`- std::collections::BTreeMap<InfoHash, entry::Single>: 'a,`
	`25`	`+ std::collections::BTreeMap<InfoHash, EntrySingle>: 'a,`
`26`	`26`	`{`
`27`	`27`	`self.torrents.write().expect("it should get the write lock")`
`28`	`28`	`}`
`@@ -32,7 +32,7 @@ impl UpdateTorrentSync for TorrentsRwLockStd {`
`32`	`32`	`fn update_torrent_with_peer_and_get_stats(&self, info_hash: &InfoHash, peer: &peer::Peer) -> (bool, SwarmMetadata) {`
`33`	`33`	`let mut db = self.get_torrents_mut();`
`34`	`34`
`35`		`- let entry = db.entry(*info_hash).or_insert(entry::Single::default());`
	`35`	`+ let entry = db.entry(*info_hash).or_insert(EntrySingle::default());`
`36`	`36`
`37`	`37`	`entry.insert_or_update_peer_and_get_stats(peer)`
`38`	`38`	`}`
`@@ -44,8 +44,8 @@ impl UpdateTorrentSync for Arc<TorrentsRwLockStd> {`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`
`47`		`-impl Repository<entry::Single> for TorrentsRwLockStd {`
`48`		`- async fn get(&self, key: &InfoHash) -> Option<entry::Single> {`
	`47`	`+impl Repository<EntrySingle> for TorrentsRwLockStd {`
	`48`	`+ async fn get(&self, key: &InfoHash) -> Option<EntrySingle> {`
`49`	`49`	`let db = self.get_torrents();`
`50`	`50`	`db.get(key).cloned()`
`51`	`51`	`}`
`@@ -64,7 +64,7 @@ impl Repository<entry::Single> for TorrentsRwLockStd {`
`64`	`64`	`metrics`
`65`	`65`	`}`
`66`	`66`
`67`		`- async fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, entry::Single)> {`
	`67`	`+ async fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, EntrySingle)> {`
`68`	`68`	`let db = self.get_torrents();`
`69`	`69`
`70`	`70`	`match pagination {`
`@@ -87,7 +87,7 @@ impl Repository<entry::Single> for TorrentsRwLockStd {`
`87`	`87`	`continue;`
`88`	`88`	`}`
`89`	`89`
`90`		`- let entry = entry::Single {`
	`90`	`+ let entry = EntrySingle {`
`91`	`91`	`peers: BTreeMap::default(),`
`92`	`92`	`completed: *completed,`
`93`	`93`	`};`
`@@ -96,7 +96,7 @@ impl Repository<entry::Single> for TorrentsRwLockStd {`
`96`	`96`	`}`
`97`	`97`	`}`
`98`	`98`
`99`		`- async fn remove(&self, key: &InfoHash) -> Option<entry::Single> {`
	`99`	`+ async fn remove(&self, key: &InfoHash) -> Option<EntrySingle> {`
`100`	`100`	`let mut db = self.get_torrents_mut();`
`101`	`101`	`db.remove(key)`
`102`	`102`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,19 +13,19 @@ use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch, PersistentTorrent`
`13`	`13`
`14`	`14`	`use super::{Repository, UpdateTorrentAsync};`
`15`	`15`	`use crate::entry::{self, ReadInfo, UpdateAsync};`
`16`		`-use crate::TorrentsRwLockStdMutexTokio;`
	`16`	`+use crate::{EntryMutexTokio, EntrySingle, TorrentsRwLockStdMutexTokio};`
`17`	`17`
`18`	`18`	`impl TorrentsRwLockStdMutexTokio {`
`19`		`- fn get_torrents<'a>(&'a self) -> std::sync::RwLockReadGuard<'a, std::collections::BTreeMap<InfoHash, entry::MutexTokio>>`
	`19`	`+ fn get_torrents<'a>(&'a self) -> std::sync::RwLockReadGuard<'a, std::collections::BTreeMap<InfoHash, EntryMutexTokio>>`
`20`	`20`	`where`
`21`		`- std::collections::BTreeMap<InfoHash, entry::MutexTokio>: 'a,`
	`21`	`+ std::collections::BTreeMap<InfoHash, EntryMutexTokio>: 'a,`
`22`	`22`	`{`
`23`	`23`	`self.torrents.read().expect("unable to get torrent list")`
`24`	`24`	`}`
`25`	`25`
`26`		`- fn get_torrents_mut<'a>(&'a self) -> std::sync::RwLockWriteGuard<'a, std::collections::BTreeMap<InfoHash, entry::MutexTokio>>`
	`26`	`+ fn get_torrents_mut<'a>(&'a self) -> std::sync::RwLockWriteGuard<'a, std::collections::BTreeMap<InfoHash, EntryMutexTokio>>`
`27`	`27`	`where`
`28`		`- std::collections::BTreeMap<InfoHash, entry::MutexTokio>: 'a,`
	`28`	`+ std::collections::BTreeMap<InfoHash, EntryMutexTokio>: 'a,`
`29`	`29`	`{`
`30`	`30`	`self.torrents.write().expect("unable to get writable torrent list")`
`31`	`31`	`}`
`@@ -53,13 +53,13 @@ impl UpdateTorrentAsync for Arc<TorrentsRwLockStdMutexTokio> {`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
`56`		`-impl Repository<entry::MutexTokio> for TorrentsRwLockStdMutexTokio {`
`57`		`- async fn get(&self, key: &InfoHash) -> Option<entry::MutexTokio> {`
	`56`	`+impl Repository<EntryMutexTokio> for TorrentsRwLockStdMutexTokio {`
	`57`	`+ async fn get(&self, key: &InfoHash) -> Option<EntryMutexTokio> {`
`58`	`58`	`let db = self.get_torrents();`
`59`	`59`	`db.get(key).cloned()`
`60`	`60`	`}`
`61`	`61`
`62`		`- async fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, entry::MutexTokio)> {`
	`62`	`+ async fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, EntryMutexTokio)> {`
`63`	`63`	`let db = self.get_torrents();`
`64`	`64`
`65`	`65`	`match pagination {`
`@@ -98,8 +98,8 @@ impl Repository<entry::MutexTokio> for TorrentsRwLockStdMutexTokio {`
`98`	`98`	`continue;`
`99`	`99`	`}`
`100`	`100`
`101`		`- let entry = entry::MutexTokio::new(`
`102`		`- entry::Single {`
	`101`	`+ let entry = EntryMutexTokio::new(`
	`102`	`+ EntrySingle {`
`103`	`103`	`peers: BTreeMap::default(),`
`104`	`104`	`completed: *completed,`
`105`	`105`	`}`
`@@ -110,7 +110,7 @@ impl Repository<entry::MutexTokio> for TorrentsRwLockStdMutexTokio {`
`110`	`110`	`}`
`111`	`111`	`}`
`112`	`112`
`113`		`- async fn remove(&self, key: &InfoHash) -> Option<entry::MutexTokio> {`
	`113`	`+ async fn remove(&self, key: &InfoHash) -> Option<EntryMutexTokio> {`
`114`	`114`	`let mut db = self.get_torrents_mut();`
`115`	`115`	`db.remove(key)`
`116`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,22 +9,22 @@ use torrust_tracker_primitives::torrent_metrics::TorrentsMetrics;`
`9`	`9`	`use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch, PersistentTorrents};`
`10`	`10`
`11`	`11`	`use super::{Repository, UpdateTorrentAsync};`
`12`		`-use crate::entry::{self, ReadInfo, Update};`
`13`		`-use crate::TorrentsRwLockTokio;`
	`12`	`+use crate::entry::{ReadInfo, Update};`
	`13`	`+use crate::{EntrySingle, TorrentsRwLockTokio};`
`14`	`14`
`15`	`15`	`impl TorrentsRwLockTokio {`
`16`		`- async fn get_torrents<'a>(&'a self) -> tokio::sync::RwLockReadGuard<'a, std::collections::BTreeMap<InfoHash, entry::Single>>`
	`16`	`+ async fn get_torrents<'a>(&'a self) -> tokio::sync::RwLockReadGuard<'a, std::collections::BTreeMap<InfoHash, EntrySingle>>`
`17`	`17`	`where`
`18`		`- std::collections::BTreeMap<InfoHash, entry::Single>: 'a,`
	`18`	`+ std::collections::BTreeMap<InfoHash, EntrySingle>: 'a,`
`19`	`19`	`{`
`20`	`20`	`self.torrents.read().await`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`async fn get_torrents_mut<'a>(`
`24`	`24`	`&'a self,`
`25`		`- ) -> tokio::sync::RwLockWriteGuard<'a, std::collections::BTreeMap<InfoHash, entry::Single>>`
	`25`	`+ ) -> tokio::sync::RwLockWriteGuard<'a, std::collections::BTreeMap<InfoHash, EntrySingle>>`
`26`	`26`	`where`
`27`		`- std::collections::BTreeMap<InfoHash, entry::Single>: 'a,`
	`27`	`+ std::collections::BTreeMap<InfoHash, EntrySingle>: 'a,`
`28`	`28`	`{`
`29`	`29`	`self.torrents.write().await`
`30`	`30`	`}`
`@@ -34,7 +34,7 @@ impl UpdateTorrentAsync for TorrentsRwLockTokio {`
`34`	`34`	`async fn update_torrent_with_peer_and_get_stats(&self, info_hash: &InfoHash, peer: &peer::Peer) -> (bool, SwarmMetadata) {`
`35`	`35`	`let mut db = self.get_torrents_mut().await;`
`36`	`36`
`37`		`- let entry = db.entry(*info_hash).or_insert(entry::Single::default());`
	`37`	`+ let entry = db.entry(*info_hash).or_insert(EntrySingle::default());`
`38`	`38`
`39`	`39`	`entry.insert_or_update_peer_and_get_stats(peer)`
`40`	`40`	`}`
`@@ -46,13 +46,13 @@ impl UpdateTorrentAsync for Arc<TorrentsRwLockTokio> {`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
`49`		`-impl Repository<entry::Single> for TorrentsRwLockTokio {`
`50`		`- async fn get(&self, key: &InfoHash) -> Option<entry::Single> {`
	`49`	`+impl Repository<EntrySingle> for TorrentsRwLockTokio {`
	`50`	`+ async fn get(&self, key: &InfoHash) -> Option<EntrySingle> {`
`51`	`51`	`let db = self.get_torrents().await;`
`52`	`52`	`db.get(key).cloned()`
`53`	`53`	`}`
`54`	`54`
`55`		`- async fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, entry::Single)> {`
	`55`	`+ async fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, EntrySingle)> {`
`56`	`56`	`let db = self.get_torrents().await;`
`57`	`57`
`58`	`58`	`match pagination {`
`@@ -89,7 +89,7 @@ impl Repository<entry::Single> for TorrentsRwLockTokio {`
`89`	`89`	`continue;`
`90`	`90`	`}`
`91`	`91`
`92`		`- let entry = entry::Single {`
	`92`	`+ let entry = EntrySingle {`
`93`	`93`	`peers: BTreeMap::default(),`
`94`	`94`	`completed: *completed,`
`95`	`95`	`};`
`@@ -98,7 +98,7 @@ impl Repository<entry::Single> for TorrentsRwLockTokio {`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`
`101`		`- async fn remove(&self, key: &InfoHash) -> Option<entry::Single> {`
	`101`	`+ async fn remove(&self, key: &InfoHash) -> Option<EntrySingle> {`
`102`	`102`	`let mut db = self.get_torrents_mut().await;`
`103`	`103`	`db.remove(key)`
`104`	`104`	`}`