fix: [torrust#1491] deadlock running tests

I don't know why it was not happening before. The previous changes only:

- Remove types aliases.
- Remove generics.
- Remove unused traits.

However the concrete type for the repository should be the same after
monomorphization.

Author: josecelano

Cargo.lock

@@ -23,6 +23,7 @@ tokio = { version = "1", features = ["macros", "net", "rt-multi-thread", "signal
 torrust-tracker-clock = { version = "3.0.0-develop", path = "../clock" }
 torrust-tracker-configuration = { version = "3.0.0-develop", path = "../configuration" }
 torrust-tracker-primitives = { version = "3.0.0-develop", path = "../primitives" }
+tracing = "0"
 
 [dev-dependencies]
 async-std = { version = "1", features = ["attributes", "tokio1"] }

packages/torrent-repository/Cargo.toml

@@ -42,12 +42,16 @@ impl TorrentsSkipMapMutexStd {
         opt_persistent_torrent: Option<PersistentTorrent>,
     ) -> bool {
         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 torrent entry")
                 .upsert_peer(peer)
         } else {
+            tracing::debug!("Inserting new torrent: {:?}", info_hash);
+
             let new_entry = if let Some(number_of_downloads) = opt_persistent_torrent {
                 EntryMutexStd::new(
                     Torrent {
@@ -62,13 +66,9 @@ impl TorrentsSkipMapMutexStd {
 
             let inserted_entry = self.torrents.get_or_insert(*info_hash, new_entry);
 
-            let number_of_downloads_increased = inserted_entry
-                .value()
-                .lock()
-                .expect("can't acquire lock for torrent entry")
-                .upsert_peer(peer);
+            let mut torrent_guard = inserted_entry.value().lock().expect("can't acquire lock for torrent entry");
 
-            number_of_downloads_increased
+            torrent_guard.upsert_peer(peer)
         }
     }
 

packages/torrent-repository/src/repository.rs

@@ -528,20 +528,17 @@ mod tests {
             #[allow(clippy::from_over_into)]
             impl Into<TorrentEntryInfo> for TorrentEntry {
                 fn into(self) -> TorrentEntryInfo {
-                    TorrentEntryInfo {
-                        swarm_metadata: self
-                            .lock()
-                            .expect("can't acquire lock for torrent entry")
-                            .get_swarm_metadata(),
-                        peers: self
-                            .lock()
-                            .expect("can't acquire lock for torrent entry")
-                            .get_peers(None)
-                            .iter()
-                            .map(|peer| *peer.clone())
-                            .collect(),
-                        number_of_peers: self.lock().expect("can't acquire lock for torrent entry").get_peers_len(),
-                    }
+                    let torrent_guard = self.lock().expect("can't acquire lock for torrent entry");
+
+                    let torrent_entry_info = TorrentEntryInfo {
+                        swarm_metadata: torrent_guard.get_swarm_metadata(),
+                        peers: torrent_guard.get_peers(None).iter().map(|peer| *peer.clone()).collect(),
+                        number_of_peers: torrent_guard.get_peers_len(),
+                    };
+
+                    drop(torrent_guard);
+
+                    torrent_entry_info
                 }
             }
 

packages/tracker-core/src/torrent/repository/in_memory.rs

@@ -190,10 +190,12 @@ 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(|t| t.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()
+                .expect("can't acquire lock for torrent entry")
+                .get_swarm_metadata()
+        }) {
             basic_infos.push(BasicInfo {
                 info_hash: *info_hash,
                 seeders: u64::from(stats.complete),