dev: refactor torrent/repository

Author: da2ce7

cSpell.json

@@ -5,6 +5,7 @@
         "alekitto",
         "appuser",
         "Arvid",
+        "asyn",
         "autoclean",
         "AUTOINCREMENT",
         "automock",

packages/torrent-repository-benchmarks/src/benches/asyn.rs

@@ -3,13 +3,13 @@ use std::time::Duration;
 
 use clap::Parser;
 use futures::stream::FuturesUnordered;
-use torrust_tracker::core::torrent::repository::TRepositoryAsync;
+use torrust_tracker::core::torrent::repository_asyn::RepositoryAsync;
 use torrust_tracker::shared::bit_torrent::info_hash::InfoHash;
 
 use crate::args::Args;
 use crate::benches::utils::{generate_unique_info_hashes, get_average_and_adjusted_average_from_results, DEFAULT_PEER};
 
-pub async fn async_add_one_torrent<T: TRepositoryAsync + Send + Sync + 'static>(samples: usize) -> (Duration, Duration) {
+pub async fn async_add_one_torrent<T: RepositoryAsync + Send + Sync + 'static>(samples: usize) -> (Duration, Duration) {
     let mut results: Vec<Duration> = Vec::with_capacity(samples);
 
     for _ in 0..samples {
@@ -32,7 +32,7 @@ pub async fn async_add_one_torrent<T: TRepositoryAsync + Send + Sync + 'static>(
 }
 
 // Add one torrent ten thousand times in parallel (depending on the set worker threads)
-pub async fn async_update_one_torrent_in_parallel<T: TRepositoryAsync + Send + Sync + 'static>(
+pub async fn async_update_one_torrent_in_parallel<T: RepositoryAsync + Send + Sync + 'static>(
     runtime: &tokio::runtime::Runtime,
     samples: usize,
 ) -> (Duration, Duration) {
@@ -81,7 +81,7 @@ pub async fn async_update_one_torrent_in_parallel<T: TRepositoryAsync + Send + S
 }
 
 // Add ten thousand torrents in parallel (depending on the set worker threads)
-pub async fn async_add_multiple_torrents_in_parallel<T: TRepositoryAsync + Send + Sync + 'static>(
+pub async fn async_add_multiple_torrents_in_parallel<T: RepositoryAsync + Send + Sync + 'static>(
     runtime: &tokio::runtime::Runtime,
     samples: usize,
 ) -> (Duration, Duration) {
@@ -125,7 +125,7 @@ pub async fn async_add_multiple_torrents_in_parallel<T: TRepositoryAsync + Send
 }
 
 // Async update ten thousand torrents in parallel (depending on the set worker threads)
-pub async fn async_update_multiple_torrents_in_parallel<T: TRepositoryAsync + Send + Sync + 'static>(
+pub async fn async_update_multiple_torrents_in_parallel<T: RepositoryAsync + Send + Sync + 'static>(
     runtime: &tokio::runtime::Runtime,
     samples: usize,
 ) -> (Duration, Duration) {

packages/torrent-repository-benchmarks/src/benches/sync.rs

@@ -3,15 +3,15 @@ use std::time::Duration;
 
 use clap::Parser;
 use futures::stream::FuturesUnordered;
-use torrust_tracker::core::torrent::repository::Repository;
+use torrust_tracker::core::torrent::repository_sync::RepositorySync;
 use torrust_tracker::shared::bit_torrent::info_hash::InfoHash;
 
 use crate::args::Args;
 use crate::benches::utils::{generate_unique_info_hashes, get_average_and_adjusted_average_from_results, DEFAULT_PEER};
 
 // Simply add one torrent
 #[must_use]
-pub fn add_one_torrent<T: Repository + Send + Sync + 'static>(samples: usize) -> (Duration, Duration) {
+pub fn add_one_torrent<T: RepositorySync + Send + Sync + 'static>(samples: usize) -> (Duration, Duration) {
     let mut results: Vec<Duration> = Vec::with_capacity(samples);
 
     for _ in 0..samples {
@@ -32,7 +32,7 @@ pub fn add_one_torrent<T: Repository + Send + Sync + 'static>(samples: usize) ->
 }
 
 // Add one torrent ten thousand times in parallel (depending on the set worker threads)
-pub async fn update_one_torrent_in_parallel<T: Repository + Send + Sync + 'static>(
+pub async fn update_one_torrent_in_parallel<T: RepositorySync + Send + Sync + 'static>(
     runtime: &tokio::runtime::Runtime,
     samples: usize,
 ) -> (Duration, Duration) {
@@ -77,7 +77,7 @@ pub async fn update_one_torrent_in_parallel<T: Repository + Send + Sync + 'stati
 }
 
 // Add ten thousand torrents in parallel (depending on the set worker threads)
-pub async fn add_multiple_torrents_in_parallel<T: Repository + Send + Sync + 'static>(
+pub async fn add_multiple_torrents_in_parallel<T: RepositorySync + Send + Sync + 'static>(
     runtime: &tokio::runtime::Runtime,
     samples: usize,
 ) -> (Duration, Duration) {
@@ -119,7 +119,7 @@ pub async fn add_multiple_torrents_in_parallel<T: Repository + Send + Sync + 'st
 }
 
 // Update ten thousand torrents in parallel (depending on the set worker threads)
-pub async fn update_multiple_torrents_in_parallel<T: Repository + Send + Sync + 'static>(
+pub async fn update_multiple_torrents_in_parallel<T: RepositorySync + Send + Sync + 'static>(
     runtime: &tokio::runtime::Runtime,
     samples: usize,
 ) -> (Duration, Duration) {

packages/torrent-repository-benchmarks/src/main.rs

@@ -7,7 +7,8 @@ use torrust_torrent_repository_benchmarks::benches::asyn::{
 use torrust_torrent_repository_benchmarks::benches::sync::{
     add_multiple_torrents_in_parallel, add_one_torrent, update_multiple_torrents_in_parallel, update_one_torrent_in_parallel,
 };
-use torrust_tracker::core::torrent::repository::{AsyncSync, RepositoryAsync, RepositoryAsyncSingle, Sync, SyncSingle};
+use torrust_tracker::core::torrent::repository_asyn::{Async, AsyncSync, RepositoryAsyncSingle};
+use torrust_tracker::core::torrent::repository_sync::{Sync, SyncSingle};
 
 #[allow(clippy::too_many_lines)]
 #[allow(clippy::print_literal)]
@@ -118,22 +119,22 @@ fn main() {
         println!(
             "{}: Avg/AdjAvg: {:?}",
             "add_one_torrent",
-            rt.block_on(async_add_one_torrent::<RepositoryAsync>(1_000_000))
+            rt.block_on(async_add_one_torrent::<Async>(1_000_000))
         );
         println!(
             "{}: Avg/AdjAvg: {:?}",
             "update_one_torrent_in_parallel",
-            rt.block_on(async_update_one_torrent_in_parallel::<RepositoryAsync>(&rt, 10))
+            rt.block_on(async_update_one_torrent_in_parallel::<Async>(&rt, 10))
         );
         println!(
             "{}: Avg/AdjAvg: {:?}",
             "add_multiple_torrents_in_parallel",
-            rt.block_on(async_add_multiple_torrents_in_parallel::<RepositoryAsync>(&rt, 10))
+            rt.block_on(async_add_multiple_torrents_in_parallel::<Async>(&rt, 10))
         );
         println!(
             "{}: Avg/AdjAvg: {:?}",
             "update_multiple_torrents_in_parallel",
-            rt.block_on(async_update_multiple_torrents_in_parallel::<RepositoryAsync>(&rt, 10))
+            rt.block_on(async_update_multiple_torrents_in_parallel::<Async>(&rt, 10))
         );
     }
 }

src/core/mod.rs

@@ -455,7 +455,7 @@ use torrust_tracker_primitives::TrackerMode;
 use self::auth::Key;
 use self::error::Error;
 use self::peer::Peer;
-use self::torrent::repository::{RepositoryAsyncSingle, TRepositoryAsync};
+use self::torrent::repository_asyn::{RepositoryAsync, RepositoryAsyncSingle};
 use crate::core::databases::Database;
 use crate::core::torrent::{SwarmMetadata, SwarmStats};
 use crate::shared::bit_torrent::info_hash::InfoHash;

src/core/torrent/mod.rs

@@ -28,7 +28,8 @@
 //! Peer that don not have a full copy of the torrent data are called "leechers".
 //!
 //! > **NOTICE**: that both [`SwarmMetadata`] and [`SwarmStats`] contain the same information. [`SwarmMetadata`] is using the names used on [BEP 48: Tracker Protocol Extension: Scrape](https://www.bittorrent.org/beps/bep_0048.html).
-pub mod repository;
+pub mod repository_asyn;
+pub mod repository_sync;
 
 use std::time::Duration;
 

src/core/torrent/repository.rs src/core/torrent/repository_asyn.rs

@@ -4,12 +4,7 @@ use crate::core::peer;
 use crate::core::torrent::{Entry, SwarmStats};
 use crate::shared::bit_torrent::info_hash::InfoHash;
 
-pub trait Repository {
-    fn new() -> Self;
-    fn update_torrent_with_peer_and_get_stats(&self, info_hash: &InfoHash, peer: &peer::Peer) -> (SwarmStats, bool);
-}
-
-pub trait TRepositoryAsync {
+pub trait RepositoryAsync {
     fn new() -> Self;
     fn update_torrent_with_peer_and_get_stats(
         &self,
@@ -18,135 +13,13 @@ pub trait TRepositoryAsync {
     ) -> impl std::future::Future<Output = (SwarmStats, bool)> + Send;
 }
 
-/// Structure that holds all torrents. Using `std::sync` locks.
-pub struct Sync {
-    torrents: std::sync::RwLock<std::collections::BTreeMap<InfoHash, Arc<std::sync::Mutex<Entry>>>>,
-}
-
-impl Sync {
-    /// Returns the get torrents of this [`Sync`].
-    ///
-    /// # Panics
-    ///
-    /// Panics if unable to read the torrent.
-    pub fn get_torrents(
-        &self,
-    ) -> std::sync::RwLockReadGuard<'_, std::collections::BTreeMap<InfoHash, Arc<std::sync::Mutex<Entry>>>> {
-        self.torrents.read().expect("unable to get torrent list")
-    }
-
-    /// Returns the mutable get torrents of this [`Sync`].
-    ///
-    /// # Panics
-    ///
-    /// Panics if unable to write to the torrents list.
-    pub fn get_torrents_mut(
-        &self,
-    ) -> std::sync::RwLockWriteGuard<'_, std::collections::BTreeMap<InfoHash, Arc<std::sync::Mutex<Entry>>>> {
-        self.torrents.write().expect("unable to get writable torrent list")
-    }
-}
-
-impl Repository for Sync {
-    fn new() -> Self {
-        Self {
-            torrents: std::sync::RwLock::new(std::collections::BTreeMap::new()),
-        }
-    }
-
-    fn update_torrent_with_peer_and_get_stats(&self, info_hash: &InfoHash, peer: &peer::Peer) -> (SwarmStats, bool) {
-        let maybe_existing_torrent_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
-        } 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::new())));
-            entry.clone()
-        };
-
-        let (stats, stats_updated) = {
-            let mut torrent_entry_lock = torrent_entry.lock().unwrap();
-            let stats_updated = torrent_entry_lock.insert_or_update_peer(peer);
-            let stats = torrent_entry_lock.get_stats();
-
-            (stats, stats_updated)
-        };
-
-        (
-            SwarmStats {
-                downloaded: stats.1,
-                complete: stats.0,
-                incomplete: stats.2,
-            },
-            stats_updated,
-        )
-    }
-}
-
-/// Structure that holds all torrents. Using `std::sync` locks.
-pub struct SyncSingle {
-    torrents: std::sync::RwLock<std::collections::BTreeMap<InfoHash, Entry>>,
-}
-
-impl SyncSingle {
-    /// Returns the get torrents of this [`SyncSingle`].
-    ///
-    /// # Panics
-    ///
-    /// Panics if unable to get torrent list.
-    pub fn get_torrents(&self) -> std::sync::RwLockReadGuard<'_, std::collections::BTreeMap<InfoHash, Entry>> {
-        self.torrents.read().expect("unable to get torrent list")
-    }
-
-    /// Returns the get torrents of this [`SyncSingle`].
-    ///
-    /// # Panics
-    ///
-    /// Panics if unable to get writable torrent list.
-    pub fn get_torrents_mut(&self) -> std::sync::RwLockWriteGuard<'_, std::collections::BTreeMap<InfoHash, Entry>> {
-        self.torrents.write().expect("unable to get writable torrent list")
-    }
-}
-
-impl Repository for SyncSingle {
-    fn new() -> Self {
-        Self {
-            torrents: std::sync::RwLock::new(std::collections::BTreeMap::new()),
-        }
-    }
-
-    fn update_torrent_with_peer_and_get_stats(&self, info_hash: &InfoHash, peer: &peer::Peer) -> (SwarmStats, bool) {
-        let mut torrents = self.torrents.write().unwrap();
-
-        let torrent_entry = match torrents.entry(*info_hash) {
-            std::collections::btree_map::Entry::Vacant(vacant) => vacant.insert(Entry::new()),
-            std::collections::btree_map::Entry::Occupied(entry) => entry.into_mut(),
-        };
-
-        let stats_updated = torrent_entry.insert_or_update_peer(peer);
-        let stats = torrent_entry.get_stats();
-
-        (
-            SwarmStats {
-                downloaded: stats.1,
-                complete: stats.0,
-                incomplete: stats.2,
-            },
-            stats_updated,
-        )
-    }
-}
-
 /// Structure that holds all torrents. Using `tokio::sync` locks.
 #[allow(clippy::module_name_repetitions)]
-pub struct RepositoryAsync {
+pub struct Async {
     torrents: tokio::sync::RwLock<std::collections::BTreeMap<InfoHash, Arc<tokio::sync::Mutex<Entry>>>>,
 }
 
-impl TRepositoryAsync for RepositoryAsync {
+impl RepositoryAsync for Async {
     fn new() -> Self {
         Self {
             torrents: tokio::sync::RwLock::new(std::collections::BTreeMap::new()),
@@ -185,7 +58,7 @@ impl TRepositoryAsync for RepositoryAsync {
     }
 }
 
-impl RepositoryAsync {
+impl Async {
     pub async fn get_torrents(
         &self,
     ) -> tokio::sync::RwLockReadGuard<'_, std::collections::BTreeMap<InfoHash, Arc<tokio::sync::Mutex<Entry>>>> {
@@ -204,7 +77,7 @@ pub struct AsyncSync {
     torrents: tokio::sync::RwLock<std::collections::BTreeMap<InfoHash, Arc<std::sync::Mutex<Entry>>>>,
 }
 
-impl TRepositoryAsync for AsyncSync {
+impl RepositoryAsync for AsyncSync {
     fn new() -> Self {
         Self {
             torrents: tokio::sync::RwLock::new(std::collections::BTreeMap::new()),
@@ -262,7 +135,7 @@ pub struct RepositoryAsyncSingle {
     torrents: tokio::sync::RwLock<std::collections::BTreeMap<InfoHash, Entry>>,
 }
 
-impl TRepositoryAsync for RepositoryAsyncSingle {
+impl RepositoryAsync for RepositoryAsyncSingle {
     fn new() -> Self {
         Self {
             torrents: tokio::sync::RwLock::new(std::collections::BTreeMap::new()),