dev: refactor torrent/repository

Author: da2ce7

src/core/torrent/repository/std_single.rs

@@ -30,14 +30,11 @@ impl TorrentsStdRwLock<Entry> {
 
 impl UpdateTorrentSync for TorrentsStdRwLock<Entry> {
     fn update_torrent_with_peer_and_get_stats(&self, info_hash: &InfoHash, peer: &peer::Peer) -> (bool, SwarmMetadata) {
-        let mut torrents = self.torrents.write().unwrap();
+        let mut db = self.get_torrents_mut();
 
-        let torrent_entry = match torrents.entry(*info_hash) {
-            std::collections::btree_map::Entry::Vacant(vacant) => vacant.insert(Entry::default()),
-            std::collections::btree_map::Entry::Occupied(entry) => entry.into_mut(),
-        };
+        let entry = db.entry(*info_hash).or_insert(Entry::default());
 
-        torrent_entry.insert_or_update_peer_and_get_stats(peer)
+        entry.insert_or_update_peer_and_get_stats(peer)
     }
 }
 impl Repository<Entry> for TorrentsStdRwLock<Entry> {

src/core/torrent/repository/std_std.rs

@@ -30,19 +30,17 @@ impl TorrentsStdRwLock<entry::MutexStd> {
 
 impl UpdateTorrentSync for TorrentsStdRwLock<entry::MutexStd> {
     fn update_torrent_with_peer_and_get_stats(&self, info_hash: &InfoHash, peer: &peer::Peer) -> (bool, SwarmMetadata) {
-        let maybe_existing_torrent_entry = self.get_torrents().get(info_hash).cloned();
+        let maybe_entry = self.get_torrents().get(info_hash).cloned();
 
-        let torrent_entry: Arc<std::sync::Mutex<Entry>> = if let Some(existing_torrent_entry) = maybe_existing_torrent_entry {
-            existing_torrent_entry
+        let entry = if let Some(entry) = maybe_entry {
+            entry
         } else {
-            let mut torrents_lock = self.get_torrents_mut();
-            let entry = torrents_lock
-                .entry(*info_hash)
-                .or_insert(Arc::new(std::sync::Mutex::new(Entry::default())));
+            let mut db = self.get_torrents_mut();
+            let entry = db.entry(*info_hash).or_insert(Arc::default());
             entry.clone()
         };
 
-        torrent_entry.insert_or_update_peer_and_get_stats(peer)
+        entry.insert_or_update_peer_and_get_stats(peer)
     }
 }
 impl Repository<entry::MutexStd> for TorrentsStdRwLock<entry::MutexStd> {

src/core/torrent/repository/std_tokio.rs

@@ -30,17 +30,17 @@ impl TorrentsStdRwLock<entry::MutexTokio> {
 
 impl UpdateTorrentAsync for TorrentsStdRwLock<entry::MutexTokio> {
     async fn update_torrent_with_peer_and_get_stats(&self, info_hash: &InfoHash, peer: &peer::Peer) -> (bool, SwarmMetadata) {
-        let maybe_existing_torrent_entry = self.get_torrents().get(info_hash).cloned();
+        let maybe_entry = self.get_torrents().get(info_hash).cloned();
 
-        let torrent_entry = if let Some(existing_torrent_entry) = maybe_existing_torrent_entry {
-            existing_torrent_entry
+        let entry = if let Some(entry) = maybe_entry {
+            entry
         } else {
-            let mut torrents_lock = self.get_torrents_mut();
-            let entry = torrents_lock.entry(*info_hash).or_insert(Arc::default());
+            let mut db = self.get_torrents_mut();
+            let entry = db.entry(*info_hash).or_insert(Arc::default());
             entry.clone()
         };
 
-        torrent_entry.insert_or_update_peer_and_get_stats(peer).await
+        entry.insert_or_update_peer_and_get_stats(peer).await
     }
 }
 impl Repository<entry::MutexTokio> for TorrentsStdRwLock<entry::MutexTokio> {

src/core/torrent/repository/tokio_single.rs

@@ -29,11 +29,11 @@ impl TorrentsTokioRwLock<Entry> {
 
 impl UpdateTorrentAsync for TorrentsTokioRwLock<Entry> {
     async fn update_torrent_with_peer_and_get_stats(&self, info_hash: &InfoHash, peer: &peer::Peer) -> (bool, SwarmMetadata) {
-        let mut db = self.torrents.write().await;
+        let mut db = self.get_torrents_mut().await;
 
-        let torrent = db.entry(*info_hash).or_insert(Entry::default());
+        let entry = db.entry(*info_hash).or_insert(Entry::default());
 
-        torrent.insert_or_update_peer_and_get_stats(peer)
+        entry.insert_or_update_peer_and_get_stats(peer)
     }
 }
 

src/core/torrent/repository/tokio_std.rs

@@ -31,22 +31,17 @@ impl TorrentsTokioRwLock<entry::MutexStd> {
 
 impl UpdateTorrentAsync for TorrentsTokioRwLock<entry::MutexStd> {
     async fn update_torrent_with_peer_and_get_stats(&self, info_hash: &InfoHash, peer: &peer::Peer) -> (bool, SwarmMetadata) {
-        let maybe_torrent;
-        {
-            let db = self.torrents.read().await;
-            maybe_torrent = db.get(info_hash).cloned();
-        }
+        let maybe_entry = self.get_torrents().await.get(info_hash).cloned();
 
-        let torrent = if let Some(torrent) = maybe_torrent {
-            torrent
-        } else {
-            let entry = entry::MutexStd::default();
-            let mut db = self.torrents.write().await;
-            db.insert(*info_hash, entry.clone());
+        let entry = if let Some(entry) = maybe_entry {
             entry
+        } else {
+            let mut db = self.get_torrents_mut().await;
+            let entry = db.entry(*info_hash).or_insert(Arc::default());
+            entry.clone()
         };
 
-        torrent.insert_or_update_peer_and_get_stats(peer)
+        entry.insert_or_update_peer_and_get_stats(peer)
     }
 }
 

src/core/torrent/repository/tokio_tokio.rs

@@ -33,22 +33,17 @@ impl TorrentsTokioRwLock<entry::MutexTokio> {
 
 impl UpdateTorrentAsync for TorrentsTokioRwLock<entry::MutexTokio> {
     async fn update_torrent_with_peer_and_get_stats(&self, info_hash: &InfoHash, peer: &peer::Peer) -> (bool, SwarmMetadata) {
-        let maybe_torrent;
-        {
-            let db = self.torrents.read().await;
-            maybe_torrent = db.get(info_hash).cloned();
-        }
+        let maybe_entry = self.get_torrents().await.get(info_hash).cloned();
 
-        let torrent = if let Some(torrent) = maybe_torrent {
-            torrent
-        } else {
-            let entry = entry::MutexTokio::default();
-            let mut db = self.torrents.write().await;
-            db.insert(*info_hash, entry.clone());
+        let entry = if let Some(entry) = maybe_entry {
             entry
+        } else {
+            let mut db = self.get_torrents_mut().await;
+            let entry = db.entry(*info_hash).or_insert(Arc::default());
+            entry.clone()
         };
 
-        torrent.insert_or_update_peer_and_get_stats(peer).await
+        entry.insert_or_update_peer_and_get_stats(peer).await
     }
 }