dev: fix clippy warnings

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

@@ -62,7 +62,7 @@ pub async fn async_update_one_torrent_in_parallel<T: TRepositoryAsync + Send + S
                 if let Some(sleep_time) = args.sleep {
                     let start_time = std::time::Instant::now();
 
-                    while start_time.elapsed().as_nanos() < sleep_time as u128 {}
+                    while start_time.elapsed().as_nanos() < u128::from(sleep_time) {}
                 }
             });
 
@@ -106,7 +106,7 @@ pub async fn async_add_multiple_torrents_in_parallel<T: TRepositoryAsync + Send
                 if let Some(sleep_time) = args.sleep {
                     let start_time = std::time::Instant::now();
 
-                    while start_time.elapsed().as_nanos() < sleep_time as u128 {}
+                    while start_time.elapsed().as_nanos() < u128::from(sleep_time) {}
                 }
             });
 
@@ -138,7 +138,7 @@ pub async fn async_update_multiple_torrents_in_parallel<T: TRepositoryAsync + Se
         let handles = FuturesUnordered::new();
 
         // Add the torrents/peers to the torrent repository
-        for info_hash in info_hashes.iter() {
+        for info_hash in &info_hashes {
             torrent_repository
                 .update_torrent_with_peer_and_get_stats(info_hash, &DEFAULT_PEER)
                 .await;
@@ -157,7 +157,7 @@ pub async fn async_update_multiple_torrents_in_parallel<T: TRepositoryAsync + Se
                 if let Some(sleep_time) = args.sleep {
                     let start_time = std::time::Instant::now();
 
-                    while start_time.elapsed().as_nanos() < sleep_time as u128 {}
+                    while start_time.elapsed().as_nanos() < u128::from(sleep_time) {}
                 }
             });
 

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

@@ -4,13 +4,14 @@ use std::time::Duration;
 use clap::Parser;
 use futures::stream::FuturesUnordered;
 use torrust_tracker::shared::bit_torrent::info_hash::InfoHash;
-use torrust_tracker::tracker::torrent::repository::TRepositorySync;
+use torrust_tracker::tracker::torrent::repository::Repository;
 
 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
-pub fn add_one_torrent<T: TRepositorySync + Send + Sync + 'static>(samples: usize) -> (Duration, Duration) {
+#[must_use]
+pub fn add_one_torrent<T: Repository + Send + Sync + 'static>(samples: usize) -> (Duration, Duration) {
     let mut results: Vec<Duration> = Vec::with_capacity(samples);
 
     for _ in 0..samples {
@@ -31,7 +32,7 @@ pub fn add_one_torrent<T: TRepositorySync + Send + Sync + 'static>(samples: usiz
 }
 
 // Add one torrent ten thousand times in parallel (depending on the set worker threads)
-pub async fn update_one_torrent_in_parallel<T: TRepositorySync + Send + Sync + 'static>(
+pub async fn update_one_torrent_in_parallel<T: Repository + Send + Sync + 'static>(
     runtime: &tokio::runtime::Runtime,
     samples: usize,
 ) -> (Duration, Duration) {
@@ -57,7 +58,7 @@ pub async fn update_one_torrent_in_parallel<T: TRepositorySync + Send + Sync + '
                 if let Some(sleep_time) = args.sleep {
                     let start_time = std::time::Instant::now();
 
-                    while start_time.elapsed().as_nanos() < sleep_time as u128 {}
+                    while start_time.elapsed().as_nanos() < u128::from(sleep_time) {}
                 }
             });
 
@@ -76,7 +77,7 @@ pub async fn update_one_torrent_in_parallel<T: TRepositorySync + Send + Sync + '
 }
 
 // Add ten thousand torrents in parallel (depending on the set worker threads)
-pub async fn add_multiple_torrents_in_parallel<T: TRepositorySync + Send + Sync + 'static>(
+pub async fn add_multiple_torrents_in_parallel<T: Repository + Send + Sync + 'static>(
     runtime: &tokio::runtime::Runtime,
     samples: usize,
 ) -> (Duration, Duration) {
@@ -99,7 +100,7 @@ pub async fn add_multiple_torrents_in_parallel<T: TRepositorySync + Send + Sync
                 if let Some(sleep_time) = args.sleep {
                     let start_time = std::time::Instant::now();
 
-                    while start_time.elapsed().as_nanos() < sleep_time as u128 {}
+                    while start_time.elapsed().as_nanos() < u128::from(sleep_time) {}
                 }
             });
 
@@ -118,7 +119,7 @@ pub async fn add_multiple_torrents_in_parallel<T: TRepositorySync + Send + Sync
 }
 
 // Update ten thousand torrents in parallel (depending on the set worker threads)
-pub async fn update_multiple_torrents_in_parallel<T: TRepositorySync + Send + Sync + 'static>(
+pub async fn update_multiple_torrents_in_parallel<T: Repository + Send + Sync + 'static>(
     runtime: &tokio::runtime::Runtime,
     samples: usize,
 ) -> (Duration, Duration) {
@@ -131,7 +132,7 @@ pub async fn update_multiple_torrents_in_parallel<T: TRepositorySync + Send + Sy
         let handles = FuturesUnordered::new();
 
         // Add the torrents/peers to the torrent repository
-        for info_hash in info_hashes.iter() {
+        for info_hash in &info_hashes {
             torrent_repository.update_torrent_with_peer_and_get_stats(info_hash, &DEFAULT_PEER);
         }
 
@@ -146,7 +147,7 @@ pub async fn update_multiple_torrents_in_parallel<T: TRepositorySync + Send + Sy
                 if let Some(sleep_time) = args.sleep {
                     let start_time = std::time::Instant::now();
 
-                    while start_time.elapsed().as_nanos() < sleep_time as u128 {}
+                    while start_time.elapsed().as_nanos() < u128::from(sleep_time) {}
                 }
             });
 

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

@@ -17,11 +17,14 @@ pub const DEFAULT_PEER: Peer = Peer {
     event: AnnounceEvent::Started,
 };
 
+#[must_use]
+#[allow(clippy::missing_panics_doc)]
 pub fn generate_unique_info_hashes(size: usize) -> Vec<InfoHash> {
     let mut result = HashSet::new();
 
     let mut bytes = [0u8; 20];
 
+    #[allow(clippy::cast_possible_truncation)]
     for i in 0..size {
         bytes[0] = (i & 0xFF) as u8;
         bytes[1] = ((i >> 8) & 0xFF) as u8;
@@ -37,6 +40,7 @@ pub fn generate_unique_info_hashes(size: usize) -> Vec<InfoHash> {
     result.into_iter().collect()
 }
 
+#[must_use]
 pub fn within_acceptable_range(test: &Duration, norm: &Duration) -> bool {
     let test_secs = test.as_secs_f64();
     let norm_secs = norm.as_secs_f64();
@@ -51,13 +55,16 @@ pub fn within_acceptable_range(test: &Duration, norm: &Duration) -> bool {
     test_secs < upper_limit && test_secs > lower_limit
 }
 
+#[must_use]
 pub fn get_average_and_adjusted_average_from_results(mut results: Vec<Duration>) -> (Duration, Duration) {
+    #[allow(clippy::cast_possible_truncation)]
     let average = results.iter().sum::<Duration>() / results.len() as u32;
 
     results.retain(|result| within_acceptable_range(result, &average));
 
     let mut adjusted_average = Duration::from_nanos(0);
 
+    #[allow(clippy::cast_possible_truncation)]
     if results.len() > 1 {
         adjusted_average = results.iter().sum::<Duration>() / results.len() as u32;
     }

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

@@ -7,10 +7,10 @@ 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::tracker::torrent::repository::{
-    RepositoryAsync, RepositoryAsyncSingle, RepositoryAsyncSync, RepositorySync, RepositorySyncSingle,
-};
+use torrust_tracker::tracker::torrent::repository::{AsyncSync, RepositoryAsync, RepositoryAsyncSingle, Sync, SyncSingle};
 
+#[allow(clippy::too_many_lines)]
+#[allow(clippy::print_literal)]
 fn main() {
     let args = Args::parse();
 
@@ -44,79 +44,75 @@ fn main() {
     );
 
     if let Some(true) = args.compare {
-        println!("");
+        println!();
 
         println!("std::sync::RwLock<std::collections::BTreeMap<InfoHash, Entry>>");
         println!(
             "{}: Avg/AdjAvg: {:?}",
             "add_one_torrent",
-            add_one_torrent::<RepositorySyncSingle>(1_000_000)
+            add_one_torrent::<SyncSingle>(1_000_000)
         );
         println!(
             "{}: Avg/AdjAvg: {:?}",
             "update_one_torrent_in_parallel",
-            rt.block_on(update_one_torrent_in_parallel::<RepositorySyncSingle>(&rt, 10))
+            rt.block_on(update_one_torrent_in_parallel::<SyncSingle>(&rt, 10))
         );
         println!(
             "{}: Avg/AdjAvg: {:?}",
             "add_multiple_torrents_in_parallel",
-            rt.block_on(add_multiple_torrents_in_parallel::<RepositorySyncSingle>(&rt, 10))
+            rt.block_on(add_multiple_torrents_in_parallel::<SyncSingle>(&rt, 10))
         );
         println!(
             "{}: Avg/AdjAvg: {:?}",
             "update_multiple_torrents_in_parallel",
-            rt.block_on(update_multiple_torrents_in_parallel::<RepositorySyncSingle>(&rt, 10))
+            rt.block_on(update_multiple_torrents_in_parallel::<SyncSingle>(&rt, 10))
         );
 
-        println!("");
+        println!();
 
         println!("std::sync::RwLock<std::collections::BTreeMap<InfoHash, Arc<std::sync::Mutex<Entry>>>>");
-        println!(
-            "{}: Avg/AdjAvg: {:?}",
-            "add_one_torrent",
-            add_one_torrent::<RepositorySync>(1_000_000)
-        );
+        println!("{}: Avg/AdjAvg: {:?}", "add_one_torrent", add_one_torrent::<Sync>(1_000_000));
         println!(
             "{}: Avg/AdjAvg: {:?}",
             "update_one_torrent_in_parallel",
-            rt.block_on(update_one_torrent_in_parallel::<RepositorySync>(&rt, 10))
+            rt.block_on(update_one_torrent_in_parallel::<Sync>(&rt, 10))
         );
         println!(
             "{}: Avg/AdjAvg: {:?}",
             "add_multiple_torrents_in_parallel",
-            rt.block_on(add_multiple_torrents_in_parallel::<RepositorySync>(&rt, 10))
+            rt.block_on(add_multiple_torrents_in_parallel::<Sync>(&rt, 10))
         );
         println!(
             "{}: Avg/AdjAvg: {:?}",
             "update_multiple_torrents_in_parallel",
-            rt.block_on(update_multiple_torrents_in_parallel::<RepositorySync>(&rt, 10))
+            rt.block_on(update_multiple_torrents_in_parallel::<Sync>(&rt, 10))
         );
 
-        println!("");
+        println!();
 
         println!("tokio::sync::RwLock<std::collections::BTreeMap<InfoHash, Arc<std::sync::Mutex<Entry>>>>");
         println!(
             "{}: Avg/AdjAvg: {:?}",
             "add_one_torrent",
-            rt.block_on(async_add_one_torrent::<RepositoryAsyncSync>(1_000_000))
+            rt.block_on(async_add_one_torrent::<AsyncSync>(1_000_000))
         );
         println!(
             "{}: Avg/AdjAvg: {:?}",
             "update_one_torrent_in_parallel",
-            rt.block_on(async_update_one_torrent_in_parallel::<RepositoryAsyncSync>(&rt, 10))
+            rt.block_on(async_update_one_torrent_in_parallel::<AsyncSync>(&rt, 10))
         );
         println!(
             "{}: Avg/AdjAvg: {:?}",
             "add_multiple_torrents_in_parallel",
-            rt.block_on(async_add_multiple_torrents_in_parallel::<RepositoryAsyncSync>(&rt, 10))
+            rt.block_on(async_add_multiple_torrents_in_parallel::<AsyncSync>(&rt, 10))
         );
         println!(
             "{}: Avg/AdjAvg: {:?}",
             "update_multiple_torrents_in_parallel",
-            rt.block_on(async_update_multiple_torrents_in_parallel::<RepositoryAsyncSync>(&rt, 10))
+            rt.block_on(async_update_multiple_torrents_in_parallel::<AsyncSync>(&rt, 10))
         );
 
-        println!("");
+        println!();
 
         println!("tokio::sync::RwLock<std::collections::BTreeMap<InfoHash, Arc<tokio::sync::Mutex<Entry>>>>");
         println!(

src/lib.rs

@@ -1,3 +1,4 @@
+#![feature(async_fn_in_trait)]
 #![feature(return_position_impl_trait_in_trait)]
 //! **Torrust Tracker** is a modern and feature-rich (private) [`BitTorrent`](https://www.bittorrent.org/) tracker.
 //!

src/tracker/mod.rs

@@ -453,9 +453,9 @@ use torrust_tracker_primitives::TrackerMode;
 use self::auth::Key;
 use self::error::Error;
 use self::peer::Peer;
+use self::torrent::repository::{RepositoryAsyncSingle, TRepositoryAsync};
 use crate::shared::bit_torrent::info_hash::InfoHash;
 use crate::tracker::databases::Database;
-use crate::tracker::torrent::repository::{RepositoryAsyncSingle, TRepositoryAsync};
 use crate::tracker::torrent::{SwarmMetadata, SwarmStats};
 
 /// The domain layer tracker service.
@@ -727,7 +727,7 @@ impl Tracker {
         if self.config.persistent_torrent_completed_stat && stats_updated {
             let database = self.database.clone();
             let completed = stats.completed;
-            let info_hash = info_hash.clone();
+            let info_hash = *info_hash;
 
             drop(database.save_persistent_torrent(&info_hash, completed).await);
         }
@@ -739,6 +739,9 @@ impl Tracker {
     /// [`TorrentsMetrics`]
     ///
     /// # Context: Tracker
+    ///
+    /// # Panics
+    /// Panics if unable to get the torrent metrics.
     pub async fn get_torrents_metrics(&self) -> TorrentsMetrics {
         let arc_torrents_metrics = Arc::new(tokio::sync::Mutex::new(TorrentsMetrics {
             seeders: 0,
@@ -786,7 +789,7 @@ impl Tracker {
         if self.config.remove_peerless_torrents {
             let mut cleaned_torrents_map: BTreeMap<InfoHash, torrent::Entry> = BTreeMap::new();
 
-            for (info_hash, torrent_entry) in torrents_lock.iter_mut() {
+            for (info_hash, torrent_entry) in &mut *torrents_lock {
                 torrent_entry.remove_inactive_peers(self.config.max_peer_timeout);
 
                 if torrent_entry.peers.is_empty() {

src/tracker/services/torrent.rs

@@ -130,7 +130,7 @@ pub async fn get_torrents(tracker: Arc<Tracker>, pagination: &Pagination) -> Vec
             seeders: u64::from(seeders),
             completed: u64::from(completed),
             leechers: u64::from(leechers),
-        })
+        });
     }
 
     basic_infos