refactor: [#1491] remove duplicate code

Author: josecelano

packages/torrent-repository/src/lib.rs

@@ -1,7 +1,7 @@
 pub mod entry;
 pub mod repository;
 
-use std::sync::{Arc, Mutex};
+use std::sync::{Arc, Mutex, MutexGuard};
 
 use torrust_tracker_clock::clock;
 
@@ -19,6 +19,16 @@ pub(crate) type CurrentClock = clock::Working;
 #[allow(dead_code)]
 pub(crate) type CurrentClock = clock::Stopped;
 
+pub trait LockTrackedTorrent {
+    fn lock_or_panic(&self) -> MutexGuard<'_, TrackedTorrent>;
+}
+
+impl LockTrackedTorrent for Arc<Mutex<TrackedTorrent>> {
+    fn lock_or_panic(&self) -> MutexGuard<'_, TrackedTorrent> {
+        self.lock().expect("can't acquire lock for tracked torrent handle")
+    }
+}
+
 #[cfg(test)]
 pub(crate) mod tests {
     use std::net::{IpAddr, Ipv4Addr, SocketAddr};

packages/torrent-repository/src/repository.rs

@@ -9,7 +9,7 @@ use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch, PersistentTorrent
 
 use crate::entry::peer_list::PeerList;
 use crate::entry::torrent::TrackedTorrent;
-use crate::TrackedTorrentHandle;
+use crate::{LockTrackedTorrent, TrackedTorrentHandle};
 
 #[derive(Default, Debug)]
 pub struct TorrentRepository {
@@ -46,11 +46,7 @@ impl TorrentRepository {
         if let Some(existing_entry) = self.torrents.get(info_hash) {
             tracing::debug!("Torrent already exists: {:?}", info_hash);
 
-            existing_entry
-                .value()
-                .lock()
-                .expect("can't acquire lock for tracked torrent handle")
-                .upsert_peer(peer)
+            existing_entry.value().lock_or_panic().upsert_peer(peer)
         } else {
             tracing::debug!("Inserting new torrent: {:?}", info_hash);
 
@@ -68,10 +64,7 @@ impl TorrentRepository {
 
             let inserted_entry = self.torrents.get_or_insert(*info_hash, new_entry);
 
-            let mut torrent_guard = inserted_entry
-                .value()
-                .lock()
-                .expect("can't acquire lock for tracked torrent handle");
+            let mut torrent_guard = inserted_entry.value().lock_or_panic();
 
             torrent_guard.upsert_peer(peer)
         }
@@ -97,11 +90,7 @@ impl TorrentRepository {
     /// This function panics if the lock for the entry cannot be obtained.
     pub fn remove_inactive_peers(&self, current_cutoff: DurationSinceUnixEpoch) {
         for entry in &self.torrents {
-            entry
-                .value()
-                .lock()
-                .expect("can't acquire lock for tracked torrent handle")
-                .remove_inactive_peers(current_cutoff);
+            entry.value().lock_or_panic().remove_inactive_peers(current_cutoff);
         }
     }
 
@@ -154,13 +143,9 @@ impl TorrentRepository {
     /// This function panics if the lock for the entry cannot be obtained.
     #[must_use]
     pub fn get_swarm_metadata(&self, info_hash: &InfoHash) -> Option<SwarmMetadata> {
-        self.torrents.get(info_hash).map(|entry| {
-            entry
-                .value()
-                .lock()
-                .expect("can't acquire lock for tracked torrent handle")
-                .get_swarm_metadata()
-        })
+        self.torrents
+            .get(info_hash)
+            .map(|entry| entry.value().lock_or_panic().get_swarm_metadata())
     }
 
     /// Retrieves swarm metadata for a given torrent.
@@ -196,10 +181,7 @@ impl TorrentRepository {
     pub fn get_peers_for(&self, info_hash: &InfoHash, peer: &peer::Peer, limit: usize) -> Vec<Arc<peer::Peer>> {
         match self.get(info_hash) {
             None => vec![],
-            Some(entry) => entry
-                .lock()
-                .expect("can't acquire lock for tracked torrent handle")
-                .get_peers_for_client(&peer.peer_addr, Some(limit)),
+            Some(entry) => entry.lock_or_panic().get_peers_for_client(&peer.peer_addr, Some(limit)),
         }
     }
 
@@ -220,10 +202,7 @@ impl TorrentRepository {
     pub fn get_torrent_peers(&self, info_hash: &InfoHash, limit: usize) -> Vec<Arc<peer::Peer>> {
         match self.get(info_hash) {
             None => vec![],
-            Some(entry) => entry
-                .lock()
-                .expect("can't acquire lock for tracked torrent handle")
-                .get_peers(Some(limit)),
+            Some(entry) => entry.lock_or_panic().get_peers(Some(limit)),
         }
     }
 
@@ -237,12 +216,7 @@ impl TorrentRepository {
     /// This function panics if the lock for the entry cannot be obtained.
     pub fn remove_peerless_torrents(&self, policy: &TrackerPolicy) {
         for entry in &self.torrents {
-            if entry
-                .value()
-                .lock()
-                .expect("can't acquire lock for tracked torrent handle")
-                .meets_retaining_policy(policy)
-            {
+            if entry.value().lock_or_panic().meets_retaining_policy(policy) {
                 continue;
             }
 
@@ -293,11 +267,7 @@ impl TorrentRepository {
         let mut metrics = AggregateSwarmMetadata::default();
 
         for entry in &self.torrents {
-            let stats = entry
-                .value()
-                .lock()
-                .expect("can't acquire lock for tracked torrent handle")
-                .get_swarm_metadata();
+            let stats = entry.value().lock_or_panic().get_swarm_metadata();
             metrics.total_complete += u64::from(stats.complete);
             metrics.total_downloaded += u64::from(stats.downloaded);
             metrics.total_incomplete += u64::from(stats.incomplete);
@@ -584,7 +554,7 @@ mod tests {
 
             use crate::repository::TorrentRepository;
             use crate::tests::{sample_info_hash, sample_peer};
-            use crate::TrackedTorrentHandle;
+            use crate::{LockTrackedTorrent, TrackedTorrentHandle};
 
             /// `TorrentEntry` data is not directly accessible. It's only
             /// accessible through the trait methods. We need this temporary
@@ -599,7 +569,7 @@ mod tests {
             #[allow(clippy::from_over_into)]
             impl Into<TorrentEntryInfo> for TrackedTorrentHandle {
                 fn into(self) -> TorrentEntryInfo {
-                    let torrent_guard = self.lock().expect("can't acquire lock for tracked torrent handle");
+                    let torrent_guard = self.lock_or_panic();
 
                     let torrent_entry_info = TorrentEntryInfo {
                         swarm_metadata: torrent_guard.get_swarm_metadata(),

packages/torrent-repository/tests/common/torrent.rs

@@ -4,7 +4,7 @@ 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, TrackedTorrentHandle};
+use torrust_tracker_torrent_repository::{entry, LockTrackedTorrent, TrackedTorrentHandle};
 
 #[derive(Debug, Clone)]
 pub(crate) enum Torrent {
@@ -16,68 +16,56 @@ impl Torrent {
     pub(crate) fn get_stats(&self) -> SwarmMetadata {
         match self {
             Torrent::Single(entry) => entry.get_swarm_metadata(),
-            Torrent::MutexStd(entry) => entry
-                .lock()
-                .expect("can't acquire lock for torrent entry")
-                .get_swarm_metadata(),
+            Torrent::MutexStd(entry) => entry.lock_or_panic().get_swarm_metadata(),
         }
     }
 
     pub(crate) fn meets_retaining_policy(&self, policy: &TrackerPolicy) -> bool {
         match self {
             Torrent::Single(entry) => entry.meets_retaining_policy(policy),
-            Torrent::MutexStd(entry) => entry
-                .lock()
-                .expect("can't acquire lock for torrent entry")
-                .meets_retaining_policy(policy),
+            Torrent::MutexStd(entry) => entry.lock_or_panic().meets_retaining_policy(policy),
         }
     }
 
     pub(crate) fn peers_is_empty(&self) -> bool {
         match self {
             Torrent::Single(entry) => entry.peers_is_empty(),
-            Torrent::MutexStd(entry) => entry.lock().expect("can't acquire lock for torrent entry").peers_is_empty(),
+            Torrent::MutexStd(entry) => entry.lock_or_panic().peers_is_empty(),
         }
     }
 
     pub(crate) fn get_peers_len(&self) -> usize {
         match self {
             Torrent::Single(entry) => entry.get_peers_len(),
-            Torrent::MutexStd(entry) => entry.lock().expect("can't acquire lock for torrent entry").get_peers_len(),
+            Torrent::MutexStd(entry) => entry.lock_or_panic().get_peers_len(),
         }
     }
 
     pub(crate) fn get_peers(&self, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {
         match self {
             Torrent::Single(entry) => entry.get_peers(limit),
-            Torrent::MutexStd(entry) => entry.lock().expect("can't acquire lock for torrent entry").get_peers(limit),
+            Torrent::MutexStd(entry) => entry.lock_or_panic().get_peers(limit),
         }
     }
 
     pub(crate) fn get_peers_for_client(&self, client: &SocketAddr, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {
         match self {
             Torrent::Single(entry) => entry.get_peers_for_client(client, limit),
-            Torrent::MutexStd(entry) => entry
-                .lock()
-                .expect("can't acquire lock for torrent entry")
-                .get_peers_for_client(client, limit),
+            Torrent::MutexStd(entry) => entry.lock_or_panic().get_peers_for_client(client, limit),
         }
     }
 
     pub(crate) fn upsert_peer(&mut self, peer: &peer::Peer) -> bool {
         match self {
             Torrent::Single(entry) => entry.upsert_peer(peer),
-            Torrent::MutexStd(entry) => entry.lock().expect("can't acquire lock for torrent entry").upsert_peer(peer),
+            Torrent::MutexStd(entry) => entry.lock_or_panic().upsert_peer(peer),
         }
     }
 
     pub(crate) fn remove_inactive_peers(&mut self, current_cutoff: DurationSinceUnixEpoch) {
         match self {
             Torrent::Single(entry) => entry.remove_inactive_peers(current_cutoff),
-            Torrent::MutexStd(entry) => entry
-                .lock()
-                .expect("can't acquire lock for torrent entry")
-                .remove_inactive_peers(current_cutoff),
+            Torrent::MutexStd(entry) => entry.lock_or_panic().remove_inactive_peers(current_cutoff),
         }
     }
 }

packages/tracker-core/src/announce_handler.rs

@@ -594,6 +594,7 @@ mod tests {
 
             use aquatic_udp_protocol::AnnounceEvent;
             use torrust_tracker_test_helpers::configuration;
+            use torrust_tracker_torrent_repository::LockTrackedTorrent;
 
             use crate::announce_handler::tests::the_announce_handler::peer_ip;
             use crate::announce_handler::{AnnounceHandler, PeersWanted};
@@ -656,20 +657,10 @@ mod tests {
                     .expect("it should be able to get entry");
 
                 // It persists the number of completed peers.
-                assert_eq!(
-                    torrent_entry
-                        .lock()
-                        .expect("can't acquire lock for torrent entry")
-                        .get_swarm_metadata()
-                        .downloaded,
-                    1
-                );
+                assert_eq!(torrent_entry.lock_or_panic().get_swarm_metadata().downloaded, 1);
 
                 // It does not persist the peers
-                assert!(torrent_entry
-                    .lock()
-                    .expect("can't acquire lock for torrent entry")
-                    .peers_is_empty());
+                assert!(torrent_entry.lock_or_panic().peers_is_empty());
             }
         }
 

packages/tracker-core/src/torrent/manager.rs

@@ -110,6 +110,7 @@ mod tests {
     use std::sync::Arc;
 
     use torrust_tracker_configuration::Core;
+    use torrust_tracker_torrent_repository::LockTrackedTorrent;
 
     use super::{DatabasePersistentTorrentRepository, TorrentsManager};
     use crate::databases::setup::initialize_database;
@@ -163,8 +164,7 @@ mod tests {
                 .in_memory_torrent_repository
                 .get(&infohash)
                 .unwrap()
-                .lock()
-                .expect("can't acquire lock for torrent entry")
+                .lock_or_panic()
                 .get_swarm_metadata()
                 .downloaded,
             1

packages/tracker-core/src/torrent/services.rs

@@ -17,6 +17,7 @@ use std::sync::Arc;
 use bittorrent_primitives::info_hash::InfoHash;
 use torrust_tracker_primitives::pagination::Pagination;
 use torrust_tracker_primitives::peer;
+use torrust_tracker_torrent_repository::LockTrackedTorrent;
 
 use crate::torrent::repository::in_memory::InMemoryTorrentRepository;
 
@@ -98,15 +99,9 @@ pub fn get_torrent_info(in_memory_torrent_repository: &Arc<InMemoryTorrentReposi
 
     let torrent_entry = torrent_entry_option?;
 
-    let stats = torrent_entry
-        .lock()
-        .expect("can't acquire lock for torrent entry")
-        .get_swarm_metadata();
+    let stats = torrent_entry.lock_or_panic().get_swarm_metadata();
 
-    let peers = torrent_entry
-        .lock()
-        .expect("can't acquire lock for torrent entry")
-        .get_peers(None);
+    let peers = torrent_entry.lock_or_panic().get_peers(None);
 
     let peers = Some(peers.iter().map(|peer| (**peer)).collect());
 
@@ -148,10 +143,7 @@ pub fn get_torrents_page(
     let mut basic_infos: Vec<BasicInfo> = vec![];
 
     for (info_hash, torrent_entry) in in_memory_torrent_repository.get_paginated(pagination) {
-        let stats = torrent_entry
-            .lock()
-            .expect("can't acquire lock for torrent entry")
-            .get_swarm_metadata();
+        let stats = torrent_entry.lock_or_panic().get_swarm_metadata();
 
         basic_infos.push(BasicInfo {
             info_hash,
@@ -190,12 +182,10 @@ pub fn get_torrents(in_memory_torrent_repository: &Arc<InMemoryTorrentRepository
     let mut basic_infos: Vec<BasicInfo> = vec![];
 
     for info_hash in info_hashes {
-        if let Some(stats) = in_memory_torrent_repository.get(info_hash).map(|torrent_entry| {
-            torrent_entry
-                .lock()
-                .expect("can't acquire lock for torrent entry")
-                .get_swarm_metadata()
-        }) {
+        if let Some(stats) = in_memory_torrent_repository
+            .get(info_hash)
+            .map(|torrent_entry| torrent_entry.lock_or_panic().get_swarm_metadata())
+        {
             basic_infos.push(BasicInfo {
                 info_hash: *info_hash,
                 seeders: u64::from(stats.complete),