dev: complete torrent entry tests

da2ce7 · da2ce7 · commit 3dd693db75b6 · 2024-03-20T03:11:24.000+08:00
diff --git a/cSpell.json b/cSpell.json
@@ -94,6 +94,7 @@
         "ostr",
         "Pando",
         "peekable",
+        "peerlist",
         "proot",
         "proto",
         "Quickstart",
diff --git a/packages/configuration/src/lib.rs b/packages/configuration/src/lib.rs
@@ -246,7 +246,7 @@ use torrust_tracker_primitives::{DatabaseDriver, TrackerMode};
 /// The maximum number of returned peers for a torrent.
 pub const TORRENT_PEERS_LIMIT: usize = 74;
 
-#[derive(Copy, Clone, Debug, PartialEq, Default, Constructor)]
+#[derive(Copy, Clone, Debug, PartialEq, Constructor)]
 pub struct TrackerPolicy {
     pub remove_peerless_torrents: bool,
     pub max_peer_timeout: u32,
diff --git a/packages/torrent-repository/src/entry/mod.rs b/packages/torrent-repository/src/entry/mod.rs
@@ -17,7 +17,7 @@ pub trait Entry {
     fn get_stats(&self) -> SwarmMetadata;
 
     /// Returns True if Still a Valid Entry according to the Tracker Policy
-    fn is_not_zombie(&self, policy: &TrackerPolicy) -> bool;
+    fn is_good(&self, policy: &TrackerPolicy) -> bool;
 
     /// Returns True if the Peers is Empty
     fn peers_is_empty(&self) -> bool;
@@ -51,7 +51,7 @@ pub trait Entry {
 #[allow(clippy::module_name_repetitions)]
 pub trait EntrySync {
     fn get_stats(&self) -> SwarmMetadata;
-    fn is_not_zombie(&self, policy: &TrackerPolicy) -> bool;
+    fn is_good(&self, policy: &TrackerPolicy) -> bool;
     fn peers_is_empty(&self) -> bool;
     fn get_peers_len(&self) -> usize;
     fn get_peers(&self, limit: Option<usize>) -> Vec<Arc<peer::Peer>>;
@@ -63,15 +63,13 @@ pub trait EntrySync {
 
 #[allow(clippy::module_name_repetitions)]
 pub trait EntryAsync {
-    fn get_stats(self) -> impl std::future::Future<Output = SwarmMetadata> + Send;
-
-    #[allow(clippy::wrong_self_convention)]
-    fn is_not_zombie(self, policy: &TrackerPolicy) -> impl std::future::Future<Output = bool> + Send;
-    fn peers_is_empty(self) -> impl std::future::Future<Output = bool> + Send;
-    fn get_peers_len(self) -> impl std::future::Future<Output = usize> + Send;
-    fn get_peers(self, limit: Option<usize>) -> impl std::future::Future<Output = Vec<Arc<peer::Peer>>> + Send;
+    fn get_stats(&self) -> impl std::future::Future<Output = SwarmMetadata> + Send;
+    fn is_good(&self, policy: &TrackerPolicy) -> impl std::future::Future<Output = bool> + Send;
+    fn peers_is_empty(&self) -> impl std::future::Future<Output = bool> + Send;
+    fn get_peers_len(&self) -> impl std::future::Future<Output = usize> + Send;
+    fn get_peers(&self, limit: Option<usize>) -> impl std::future::Future<Output = Vec<Arc<peer::Peer>>> + Send;
     fn get_peers_for_peer(
-        self,
+        &self,
         client: &peer::Peer,
         limit: Option<usize>,
     ) -> impl std::future::Future<Output = Vec<Arc<peer::Peer>>> + Send;
@@ -94,5 +92,5 @@ pub struct Torrent {
     // #[serde(skip)]
     pub(crate) peers: std::collections::BTreeMap<peer::Id, Arc<peer::Peer>>,
     /// The number of peers that have ever completed downloading the torrent associated to this entry
-    pub(crate) completed: u32,
+    pub(crate) downloaded: u32,
 }
diff --git a/packages/torrent-repository/src/entry/mutex_std.rs b/packages/torrent-repository/src/entry/mutex_std.rs
@@ -12,8 +12,8 @@ impl EntrySync for EntryMutexStd {
         self.lock().expect("it should get a lock").get_stats()
     }
 
-    fn is_not_zombie(&self, policy: &TrackerPolicy) -> bool {
-        self.lock().expect("it should get a lock").is_not_zombie(policy)
+    fn is_good(&self, policy: &TrackerPolicy) -> bool {
+        self.lock().expect("it should get a lock").is_good(policy)
     }
 
     fn peers_is_empty(&self) -> bool {
diff --git a/packages/torrent-repository/src/entry/mutex_tokio.rs b/packages/torrent-repository/src/entry/mutex_tokio.rs
@@ -8,27 +8,27 @@ use super::{Entry, EntryAsync};
 use crate::EntryMutexTokio;
 
 impl EntryAsync for EntryMutexTokio {
-    async fn get_stats(self) -> SwarmMetadata {
+    async fn get_stats(&self) -> SwarmMetadata {
         self.lock().await.get_stats()
     }
 
-    async fn is_not_zombie(self, policy: &TrackerPolicy) -> bool {
-        self.lock().await.is_not_zombie(policy)
+    async fn is_good(&self, policy: &TrackerPolicy) -> bool {
+        self.lock().await.is_good(policy)
     }
 
-    async fn peers_is_empty(self) -> bool {
+    async fn peers_is_empty(&self) -> bool {
         self.lock().await.peers_is_empty()
     }
 
-    async fn get_peers_len(self) -> usize {
+    async fn get_peers_len(&self) -> usize {
         self.lock().await.get_peers_len()
     }
 
-    async fn get_peers(self, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {
+    async fn get_peers(&self, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {
         self.lock().await.get_peers(limit)
     }
 
-    async fn get_peers_for_peer(self, client: &peer::Peer, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {
+    async fn get_peers_for_peer(&self, client: &peer::Peer, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {
         self.lock().await.get_peers_for_peer(client, limit)
     }
 
diff --git a/packages/torrent-repository/src/entry/single.rs b/packages/torrent-repository/src/entry/single.rs
@@ -16,14 +16,14 @@ impl Entry for EntrySingle {
         let incomplete: u32 = self.peers.len() as u32 - complete;
 
         SwarmMetadata {
-            downloaded: self.completed,
+            downloaded: self.downloaded,
             complete,
             incomplete,
         }
     }
 
-    fn is_not_zombie(&self, policy: &TrackerPolicy) -> bool {
-        if policy.persistent_torrent_completed_stat && self.completed > 0 {
+    fn is_good(&self, policy: &TrackerPolicy) -> bool {
+        if policy.persistent_torrent_completed_stat && self.downloaded > 0 {
             return true;
         }
 
@@ -70,26 +70,26 @@ impl Entry for EntrySingle {
     }
 
     fn insert_or_update_peer(&mut self, peer: &peer::Peer) -> bool {
-        let mut did_torrent_stats_change: bool = false;
+        let mut downloaded_stats_updated: bool = false;
 
         match peer::ReadInfo::get_event(peer) {
             AnnounceEvent::Stopped => {
                 drop(self.peers.remove(&peer::ReadInfo::get_id(peer)));
             }
             AnnounceEvent::Completed => {
-                let peer_old = self.peers.insert(peer::ReadInfo::get_id(peer), Arc::new(*peer));
+                let previous = self.peers.insert(peer::ReadInfo::get_id(peer), Arc::new(*peer));
                 // Don't count if peer was not previously known and not already completed.
-                if peer_old.is_some_and(|p| p.event != AnnounceEvent::Completed) {
-                    self.completed += 1;
-                    did_torrent_stats_change = true;
+                if previous.is_some_and(|p| p.event != AnnounceEvent::Completed) {
+                    self.downloaded += 1;
+                    downloaded_stats_updated = true;
                 }
             }
             _ => {
                 drop(self.peers.insert(peer::ReadInfo::get_id(peer), Arc::new(*peer)));
             }
         }
 
-        did_torrent_stats_change
+        downloaded_stats_updated
     }
 
     fn insert_or_update_peer_and_get_stats(&mut self, peer: &peer::Peer) -> (bool, SwarmMetadata) {
diff --git a/packages/torrent-repository/src/repository/rw_lock_std.rs b/packages/torrent-repository/src/repository/rw_lock_std.rs
@@ -83,7 +83,7 @@ where
 
             let entry = EntrySingle {
                 peers: BTreeMap::default(),
-                completed: *completed,
+                downloaded: *completed,
             };
 
             torrents.insert(*info_hash, entry);
@@ -107,6 +107,6 @@ where
     fn remove_peerless_torrents(&self, policy: &TrackerPolicy) {
         let mut db = self.get_torrents_mut();
 
-        db.retain(|_, e| e.is_not_zombie(policy));
+        db.retain(|_, e| e.is_good(policy));
     }
 }
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
@@ -92,7 +92,7 @@ where
             let entry = EntryMutexStd::new(
                 EntrySingle {
                     peers: BTreeMap::default(),
-                    completed: *completed,
+                    downloaded: *completed,
                 }
                 .into(),
             );
@@ -118,6 +118,6 @@ where
     fn remove_peerless_torrents(&self, policy: &TrackerPolicy) {
         let mut db = self.get_torrents_mut();
 
-        db.retain(|_, e| e.lock().expect("it should lock entry").is_not_zombie(policy));
+        db.retain(|_, e| e.lock().expect("it should lock entry").is_good(policy));
     }
 }
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
@@ -96,7 +96,7 @@ where
             let entry = EntryMutexTokio::new(
                 EntrySingle {
                     peers: BTreeMap::default(),
-                    completed: *completed,
+                    downloaded: *completed,
                 }
                 .into(),
             );
@@ -126,6 +126,6 @@ where
     async fn remove_peerless_torrents(&self, policy: &TrackerPolicy) {
         let mut db = self.get_torrents_mut();
 
-        db.retain(|_, e| e.blocking_lock().is_not_zombie(policy));
+        db.retain(|_, e| e.blocking_lock().is_good(policy));
     }
 }
diff --git a/packages/torrent-repository/src/repository/rw_lock_tokio.rs b/packages/torrent-repository/src/repository/rw_lock_tokio.rs
@@ -84,7 +84,7 @@ where
 
             let entry = EntrySingle {
                 peers: BTreeMap::default(),
-                completed: *completed,
+                downloaded: *completed,
             };
 
             torrents.insert(*info_hash, entry);
@@ -108,6 +108,6 @@ where
     async fn remove_peerless_torrents(&self, policy: &TrackerPolicy) {
         let mut db = self.get_torrents_mut().await;
 
-        db.retain(|_, e| e.is_not_zombie(policy));
+        db.retain(|_, e| e.is_good(policy));
     }
 }
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
@@ -93,7 +93,7 @@ where
             let entry = EntryMutexStd::new(
                 EntrySingle {
                     peers: BTreeMap::default(),
-                    completed: *completed,
+                    downloaded: *completed,
                 }
                 .into(),
             );
@@ -119,6 +119,6 @@ where
     async fn remove_peerless_torrents(&self, policy: &TrackerPolicy) {
         let mut db = self.get_torrents_mut().await;
 
-        db.retain(|_, e| e.lock().expect("it should lock entry").is_not_zombie(policy));
+        db.retain(|_, e| e.lock().expect("it should lock entry").is_good(policy));
     }
 }
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
@@ -70,7 +70,7 @@ where
     async fn get_metrics(&self) -> TorrentsMetrics {
         let mut metrics = TorrentsMetrics::default();
 
-        for entry in self.get_torrents().await.values().cloned() {
+        for entry in self.get_torrents().await.values() {
             let stats = entry.get_stats().await;
             metrics.seeders += u64::from(stats.complete);
             metrics.completed += u64::from(stats.downloaded);
@@ -93,7 +93,7 @@ where
             let entry = EntryMutexTokio::new(
                 EntrySingle {
                     peers: BTreeMap::default(),
-                    completed: *completed,
+                    downloaded: *completed,
                 }
                 .into(),
             );
@@ -119,6 +119,6 @@ where
     async fn remove_peerless_torrents(&self, policy: &TrackerPolicy) {
         let mut db = self.get_torrents_mut().await;
 
-        db.retain(|_, e| e.blocking_lock().is_not_zombie(policy));
+        db.retain(|_, e| e.blocking_lock().is_good(policy));
     }
 }
diff --git a/packages/torrent-repository/tests/common/torrent_peer_builder.rs b/packages/torrent-repository/tests/common/torrent_peer_builder.rs
@@ -28,6 +28,12 @@ impl TorrentPeerBuilder {
         self
     }
 
+    #[must_use]
+    pub fn with_event_started(mut self) -> Self {
+        self.peer.event = AnnounceEvent::Started;
+        self
+    }
+
     #[must_use]
     pub fn with_peer_address(mut self, peer_addr: SocketAddr) -> Self {
         self.peer.peer_addr = peer_addr;
@@ -61,7 +67,7 @@ impl TorrentPeerBuilder {
 /// A torrent seeder is a peer with 0 bytes left to download which
 /// has not announced it has stopped
 #[must_use]
-pub fn a_torrent_seeder() -> peer::Peer {
+pub fn a_completed_peer() -> peer::Peer {
     TorrentPeerBuilder::new()
         .with_number_of_bytes_left(0)
         .with_event_completed()
@@ -71,9 +77,9 @@ pub fn a_torrent_seeder() -> peer::Peer {
 /// A torrent leecher is a peer that is not a seeder.
 /// Leecher: left > 0 OR event = Stopped
 #[must_use]
-pub fn a_torrent_leecher() -> peer::Peer {
+pub fn a_started_peer() -> peer::Peer {
     TorrentPeerBuilder::new()
         .with_number_of_bytes_left(1)
-        .with_event_completed()
+        .with_event_started()
         .into()
 }
diff --git a/packages/torrent-repository/tests/entry/mod.rs b/packages/torrent-repository/tests/entry/mod.rs
diff --git a/src/core/databases/mod.rs b/src/core/databases/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,8 @@ impl EntrySync for EntryMutexStd {`
`12`	`12`	`self.lock().expect("it should get a lock").get_stats()`
`13`	`13`	`}`
`14`	`14`
`15`		`- fn is_not_zombie(&self, policy: &TrackerPolicy) -> bool {`
`16`		`- self.lock().expect("it should get a lock").is_not_zombie(policy)`
	`15`	`+ fn is_good(&self, policy: &TrackerPolicy) -> bool {`
	`16`	`+ self.lock().expect("it should get a lock").is_good(policy)`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`fn peers_is_empty(&self) -> bool {`
Original file line number	Diff line number	Diff line change
`@@ -8,27 +8,27 @@ use super::{Entry, EntryAsync};`
`8`	`8`	`use crate::EntryMutexTokio;`
`9`	`9`
`10`	`10`	`impl EntryAsync for EntryMutexTokio {`
`11`		`- async fn get_stats(self) -> SwarmMetadata {`
	`11`	`+ async fn get_stats(&self) -> SwarmMetadata {`
`12`	`12`	`self.lock().await.get_stats()`
`13`	`13`	`}`
`14`	`14`
`15`		`- async fn is_not_zombie(self, policy: &TrackerPolicy) -> bool {`
`16`		`- self.lock().await.is_not_zombie(policy)`
	`15`	`+ async fn is_good(&self, policy: &TrackerPolicy) -> bool {`
	`16`	`+ self.lock().await.is_good(policy)`
`17`	`17`	`}`
`18`	`18`
`19`		`- async fn peers_is_empty(self) -> bool {`
	`19`	`+ async fn peers_is_empty(&self) -> bool {`
`20`	`20`	`self.lock().await.peers_is_empty()`
`21`	`21`	`}`
`22`	`22`
`23`		`- async fn get_peers_len(self) -> usize {`
	`23`	`+ async fn get_peers_len(&self) -> usize {`
`24`	`24`	`self.lock().await.get_peers_len()`
`25`	`25`	`}`
`26`	`26`
`27`		`- async fn get_peers(self, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {`
	`27`	`+ async fn get_peers(&self, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {`
`28`	`28`	`self.lock().await.get_peers(limit)`
`29`	`29`	`}`
`30`	`30`
`31`		`- async fn get_peers_for_peer(self, client: &peer::Peer, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {`
	`31`	`+ async fn get_peers_for_peer(&self, client: &peer::Peer, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {`
`32`	`32`	`self.lock().await.get_peers_for_peer(client, limit)`
`33`	`33`	`}`
`34`	`34`
Original file line number	Diff line number	Diff line change
`@@ -16,14 +16,14 @@ impl Entry for EntrySingle {`
`16`	`16`	`let incomplete: u32 = self.peers.len() as u32 - complete;`
`17`	`17`
`18`	`18`	`SwarmMetadata {`
`19`		`- downloaded: self.completed,`
	`19`	`+ downloaded: self.downloaded,`
`20`	`20`	`complete,`
`21`	`21`	`incomplete,`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
`25`		`- fn is_not_zombie(&self, policy: &TrackerPolicy) -> bool {`
`26`		`- if policy.persistent_torrent_completed_stat && self.completed > 0 {`
	`25`	`+ fn is_good(&self, policy: &TrackerPolicy) -> bool {`
	`26`	`+ if policy.persistent_torrent_completed_stat && self.downloaded > 0 {`
`27`	`27`	`return true;`
`28`	`28`	`}`
`29`	`29`
`@@ -70,26 +70,26 @@ impl Entry for EntrySingle {`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`fn insert_or_update_peer(&mut self, peer: &peer::Peer) -> bool {`
`73`		`- let mut did_torrent_stats_change: bool = false;`
	`73`	`+ let mut downloaded_stats_updated: bool = false;`
`74`	`74`
`75`	`75`	`match peer::ReadInfo::get_event(peer) {`
`76`	`76`	`AnnounceEvent::Stopped => {`
`77`	`77`	`drop(self.peers.remove(&peer::ReadInfo::get_id(peer)));`
`78`	`78`	`}`
`79`	`79`	`AnnounceEvent::Completed => {`
`80`		`- let peer_old = self.peers.insert(peer::ReadInfo::get_id(peer), Arc::new(*peer));`
	`80`	`+ let previous = self.peers.insert(peer::ReadInfo::get_id(peer), Arc::new(*peer));`
`81`	`81`	`// Don't count if peer was not previously known and not already completed.`
`82`		`- if peer_old.is_some_and(\|p\| p.event != AnnounceEvent::Completed) {`
`83`		`- self.completed += 1;`
`84`		`- did_torrent_stats_change = true;`
	`82`	`+ if previous.is_some_and(\|p\| p.event != AnnounceEvent::Completed) {`
	`83`	`+ self.downloaded += 1;`
	`84`	`+ downloaded_stats_updated = true;`
`85`	`85`	`}`
`86`	`86`	`}`
`87`	`87`	`_ => {`
`88`	`88`	`drop(self.peers.insert(peer::ReadInfo::get_id(peer), Arc::new(*peer)));`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`
`92`		`- did_torrent_stats_change`
	`92`	`+ downloaded_stats_updated`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`fn insert_or_update_peer_and_get_stats(&mut self, peer: &peer::Peer) -> (bool, SwarmMetadata) {`
Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ where`
`83`	`83`
`84`	`84`	`let entry = EntrySingle {`
`85`	`85`	`peers: BTreeMap::default(),`
`86`		`- completed: *completed,`
	`86`	`+ downloaded: *completed,`
`87`	`87`	`};`
`88`	`88`
`89`	`89`	`torrents.insert(*info_hash, entry);`
`@@ -107,6 +107,6 @@ where`
`107`	`107`	`fn remove_peerless_torrents(&self, policy: &TrackerPolicy) {`
`108`	`108`	`let mut db = self.get_torrents_mut();`
`109`	`109`
`110`		`- db.retain(\|_, e\| e.is_not_zombie(policy));`
	`110`	`+ db.retain(\|_, e\| e.is_good(policy));`
`111`	`111`	`}`
`112`	`112`	`}`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ where`
`92`	`92`	`let entry = EntryMutexStd::new(`
`93`	`93`	`EntrySingle {`
`94`	`94`	`peers: BTreeMap::default(),`
`95`		`- completed: *completed,`
	`95`	`+ downloaded: *completed,`
`96`	`96`	`}`
`97`	`97`	`.into(),`
`98`	`98`	`);`
`@@ -118,6 +118,6 @@ where`
`118`	`118`	`fn remove_peerless_torrents(&self, policy: &TrackerPolicy) {`
`119`	`119`	`let mut db = self.get_torrents_mut();`
`120`	`120`
`121`		`- db.retain(\|_, e\| e.lock().expect("it should lock entry").is_not_zombie(policy));`
	`121`	`+ db.retain(\|_, e\| e.lock().expect("it should lock entry").is_good(policy));`
`122`	`122`	`}`
`123`	`123`	`}`
Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,7 @@ where`
`96`	`96`	`let entry = EntryMutexTokio::new(`
`97`	`97`	`EntrySingle {`
`98`	`98`	`peers: BTreeMap::default(),`
`99`		`- completed: *completed,`
	`99`	`+ downloaded: *completed,`
`100`	`100`	`}`
`101`	`101`	`.into(),`
`102`	`102`	`);`
`@@ -126,6 +126,6 @@ where`
`126`	`126`	`async fn remove_peerless_torrents(&self, policy: &TrackerPolicy) {`
`127`	`127`	`let mut db = self.get_torrents_mut();`
`128`	`128`
`129`		`- db.retain(\|_, e\| e.blocking_lock().is_not_zombie(policy));`
	`129`	`+ db.retain(\|_, e\| e.blocking_lock().is_good(policy));`
`130`	`130`	`}`
`131`	`131`	`}`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ where`
`84`	`84`
`85`	`85`	`let entry = EntrySingle {`
`86`	`86`	`peers: BTreeMap::default(),`
`87`		`- completed: *completed,`
	`87`	`+ downloaded: *completed,`
`88`	`88`	`};`
`89`	`89`
`90`	`90`	`torrents.insert(*info_hash, entry);`
`@@ -108,6 +108,6 @@ where`
`108`	`108`	`async fn remove_peerless_torrents(&self, policy: &TrackerPolicy) {`
`109`	`109`	`let mut db = self.get_torrents_mut().await;`
`110`	`110`
`111`		`- db.retain(\|_, e\| e.is_not_zombie(policy));`
	`111`	`+ db.retain(\|_, e\| e.is_good(policy));`
`112`	`112`	`}`
`113`	`113`	`}`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ where`
`93`	`93`	`let entry = EntryMutexStd::new(`
`94`	`94`	`EntrySingle {`
`95`	`95`	`peers: BTreeMap::default(),`
`96`		`- completed: *completed,`
	`96`	`+ downloaded: *completed,`
`97`	`97`	`}`
`98`	`98`	`.into(),`
`99`	`99`	`);`
`@@ -119,6 +119,6 @@ where`
`119`	`119`	`async fn remove_peerless_torrents(&self, policy: &TrackerPolicy) {`
`120`	`120`	`let mut db = self.get_torrents_mut().await;`
`121`	`121`
`122`		`- db.retain(\|_, e\| e.lock().expect("it should lock entry").is_not_zombie(policy));`
	`122`	`+ db.retain(\|_, e\| e.lock().expect("it should lock entry").is_good(policy));`
`123`	`123`	`}`
`124`	`124`	`}`