clippy: fix src/tracker/mod.rs

Author: da2ce7

src/api/server.rs

@@ -11,7 +11,7 @@ use super::resources::auth_key_resource::AuthKeyResource;
 use super::resources::stats_resource::StatsResource;
 use super::resources::torrent_resource::{TorrentListItemResource, TorrentPeerResource, TorrentResource};
 use crate::protocol::common::InfoHash;
-use crate::tracker::TorrentTracker;
+use crate::tracker;
 
 #[derive(Deserialize, Debug)]
 struct TorrentInfoQuery {
@@ -60,7 +60,7 @@ fn authenticate(tokens: HashMap<String, String>) -> impl Filter<Extract = (), Er
 }
 
 #[allow(clippy::too_many_lines)]
-pub fn start(socket_addr: SocketAddr, tracker: &Arc<TorrentTracker>) -> impl warp::Future<Output = ()> {
+pub fn start(socket_addr: SocketAddr, tracker: &Arc<tracker::Tracker>) -> impl warp::Future<Output = ()> {
     // GET /api/torrents?offset=:u32&limit=:u32
     // View torrent list
     let api_torrents = tracker.clone();
@@ -72,7 +72,7 @@ pub fn start(socket_addr: SocketAddr, tracker: &Arc<TorrentTracker>) -> impl war
             let tracker = api_torrents.clone();
             (limits, tracker)
         })
-        .and_then(|(limits, tracker): (TorrentInfoQuery, Arc<TorrentTracker>)| async move {
+        .and_then(|(limits, tracker): (TorrentInfoQuery, Arc<tracker::Tracker>)| async move {
             let offset = limits.offset.unwrap_or(0);
             let limit = min(limits.limit.unwrap_or(1000), 4000);
 
@@ -103,7 +103,7 @@ pub fn start(socket_addr: SocketAddr, tracker: &Arc<TorrentTracker>) -> impl war
         .and(filters::path::path("stats"))
         .and(filters::path::end())
         .map(move || api_stats.clone())
-        .and_then(|tracker: Arc<TorrentTracker>| async move {
+        .and_then(|tracker: Arc<tracker::Tracker>| async move {
             let mut results = StatsResource {
                 torrents: 0,
                 seeders: 0,
@@ -165,7 +165,7 @@ pub fn start(socket_addr: SocketAddr, tracker: &Arc<TorrentTracker>) -> impl war
             let tracker = t2.clone();
             (info_hash, tracker)
         })
-        .and_then(|(info_hash, tracker): (InfoHash, Arc<TorrentTracker>)| async move {
+        .and_then(|(info_hash, tracker): (InfoHash, Arc<tracker::Tracker>)| async move {
             let db = tracker.get_torrents().await;
             let torrent_entry_option = db.get(&info_hash);
 
@@ -201,7 +201,7 @@ pub fn start(socket_addr: SocketAddr, tracker: &Arc<TorrentTracker>) -> impl war
             let tracker = t3.clone();
             (info_hash, tracker)
         })
-        .and_then(|(info_hash, tracker): (InfoHash, Arc<TorrentTracker>)| async move {
+        .and_then(|(info_hash, tracker): (InfoHash, Arc<tracker::Tracker>)| async move {
             match tracker.remove_torrent_from_whitelist(&info_hash).await {
                 Ok(_) => Ok(warp::reply::json(&ActionStatus::Ok)),
                 Err(_) => Err(warp::reject::custom(ActionStatus::Err {
@@ -221,7 +221,7 @@ pub fn start(socket_addr: SocketAddr, tracker: &Arc<TorrentTracker>) -> impl war
             let tracker = t4.clone();
             (info_hash, tracker)
         })
-        .and_then(|(info_hash, tracker): (InfoHash, Arc<TorrentTracker>)| async move {
+        .and_then(|(info_hash, tracker): (InfoHash, Arc<tracker::Tracker>)| async move {
             match tracker.add_torrent_to_whitelist(&info_hash).await {
                 Ok(..) => Ok(warp::reply::json(&ActionStatus::Ok)),
                 Err(..) => Err(warp::reject::custom(ActionStatus::Err {
@@ -241,7 +241,7 @@ pub fn start(socket_addr: SocketAddr, tracker: &Arc<TorrentTracker>) -> impl war
             let tracker = t5.clone();
             (seconds_valid, tracker)
         })
-        .and_then(|(seconds_valid, tracker): (u64, Arc<TorrentTracker>)| async move {
+        .and_then(|(seconds_valid, tracker): (u64, Arc<tracker::Tracker>)| async move {
             match tracker.generate_auth_key(Duration::from_secs(seconds_valid)).await {
                 Ok(auth_key) => Ok(warp::reply::json(&AuthKeyResource::from(auth_key))),
                 Err(..) => Err(warp::reject::custom(ActionStatus::Err {
@@ -261,7 +261,7 @@ pub fn start(socket_addr: SocketAddr, tracker: &Arc<TorrentTracker>) -> impl war
             let tracker = t6.clone();
             (key, tracker)
         })
-        .and_then(|(key, tracker): (String, Arc<TorrentTracker>)| async move {
+        .and_then(|(key, tracker): (String, Arc<tracker::Tracker>)| async move {
             match tracker.remove_auth_key(&key).await {
                 Ok(_) => Ok(warp::reply::json(&ActionStatus::Ok)),
                 Err(_) => Err(warp::reject::custom(ActionStatus::Err {
@@ -278,7 +278,7 @@ pub fn start(socket_addr: SocketAddr, tracker: &Arc<TorrentTracker>) -> impl war
         .and(filters::path::path("reload"))
         .and(filters::path::end())
         .map(move || t7.clone())
-        .and_then(|tracker: Arc<TorrentTracker>| async move {
+        .and_then(|tracker: Arc<tracker::Tracker>| async move {
             match tracker.load_whitelist().await {
                 Ok(_) => Ok(warp::reply::json(&ActionStatus::Ok)),
                 Err(_) => Err(warp::reject::custom(ActionStatus::Err {
@@ -295,7 +295,7 @@ pub fn start(socket_addr: SocketAddr, tracker: &Arc<TorrentTracker>) -> impl war
         .and(filters::path::path("reload"))
         .and(filters::path::end())
         .map(move || t8.clone())
-        .and_then(|tracker: Arc<TorrentTracker>| async move {
+        .and_then(|tracker: Arc<tracker::Tracker>| async move {
             match tracker.load_keys().await {
                 Ok(_) => Ok(warp::reply::json(&ActionStatus::Ok)),
                 Err(_) => Err(warp::reject::custom(ActionStatus::Err {

src/http/filters.rs

@@ -9,12 +9,14 @@ use super::errors::ServerError;
 use super::request::{Announce, AnnounceRequestQuery, Scrape};
 use super::WebResult;
 use crate::protocol::common::{InfoHash, PeerId, MAX_SCRAPE_TORRENTS};
+use crate::tracker;
 use crate::tracker::key::Auth;
-use crate::tracker::TorrentTracker;
 
-/// Pass Arc<TorrentTracker> along
+/// Pass Arc<tracker::TorrentTracker> along
 #[must_use]
-pub fn with_tracker(tracker: Arc<TorrentTracker>) -> impl Filter<Extract = (Arc<TorrentTracker>,), Error = Infallible> + Clone {
+pub fn with_tracker(
+    tracker: Arc<tracker::Tracker>,
+) -> impl Filter<Extract = (Arc<tracker::Tracker>,), Error = Infallible> + Clone {
     warp::any().map(move || tracker.clone())
 }
 
@@ -30,7 +32,7 @@ pub fn with_peer_id() -> impl Filter<Extract = (PeerId,), Error = Rejection> + C
     warp::filters::query::raw().and_then(|q| async move { peer_id(&q) })
 }
 
-/// Pass Arc<TorrentTracker> along
+/// Pass Arc<tracker::TorrentTracker> along
 #[must_use]
 pub fn with_auth_key() -> impl Filter<Extract = (Option<Auth>,), Error = Infallible> + Clone {
     warp::path::param::<String>()

src/http/handlers.rs

@@ -13,7 +13,7 @@ use super::{request, WebResult};
 use crate::http::response::Error;
 use crate::protocol::common::InfoHash;
 use crate::tracker::key::Auth;
-use crate::tracker::{peer, statistics, torrent, TorrentTracker};
+use crate::tracker::{self, peer, statistics, torrent};
 
 /// Authenticate `InfoHash` using optional `AuthKey`
 ///
@@ -23,7 +23,7 @@ use crate::tracker::{peer, statistics, torrent, TorrentTracker};
 pub async fn authenticate(
     info_hash: &InfoHash,
     auth_key: &Option<Auth>,
-    tracker: Arc<TorrentTracker>,
+    tracker: Arc<tracker::Tracker>,
 ) -> Result<(), ServerError> {
     tracker.authenticate_request(info_hash, auth_key).await.map_err(|e| match e {
         torrent::Error::TorrentNotWhitelisted => ServerError::TorrentNotWhitelisted,
@@ -43,7 +43,7 @@ pub async fn authenticate(
 pub async fn handle_announce(
     announce_request: request::Announce,
     auth_key: Option<Auth>,
-    tracker: Arc<TorrentTracker>,
+    tracker: Arc<tracker::Tracker>,
 ) -> WebResult<impl Reply> {
     authenticate(&announce_request.info_hash, &auth_key, tracker.clone())
         .await
@@ -89,7 +89,7 @@ pub async fn handle_announce(
 pub async fn handle_scrape(
     scrape_request: request::Scrape,
     auth_key: Option<Auth>,
-    tracker: Arc<TorrentTracker>,
+    tracker: Arc<tracker::Tracker>,
 ) -> WebResult<impl Reply> {
     let mut files: HashMap<InfoHash, ScrapeResponseEntry> = HashMap::new();
     let db = tracker.get_torrents().await;

src/http/routes.rs

@@ -5,18 +5,18 @@ use warp::{Filter, Rejection};
 
 use super::filters::{with_announce_request, with_auth_key, with_scrape_request, with_tracker};
 use super::handlers::{handle_announce, handle_scrape, send_error};
-use crate::tracker::TorrentTracker;
+use crate::tracker;
 
 /// All routes
 #[must_use]
-pub fn routes(tracker: Arc<TorrentTracker>) -> impl Filter<Extract = impl warp::Reply, Error = Infallible> + Clone {
+pub fn routes(tracker: Arc<tracker::Tracker>) -> impl Filter<Extract = impl warp::Reply, Error = Infallible> + Clone {
     announce(tracker.clone())
         .or(scrape(tracker))
         .recover(|q| async move { send_error(&q) })
 }
 
 /// GET /announce or /announce/<key>
-fn announce(tracker: Arc<TorrentTracker>) -> impl Filter<Extract = impl warp::Reply, Error = Rejection> + Clone {
+fn announce(tracker: Arc<tracker::Tracker>) -> impl Filter<Extract = impl warp::Reply, Error = Rejection> + Clone {
     warp::path::path("announce")
         .and(warp::filters::method::get())
         .and(with_announce_request(tracker.config.on_reverse_proxy))
@@ -26,7 +26,7 @@ fn announce(tracker: Arc<TorrentTracker>) -> impl Filter<Extract = impl warp::Re
 }
 
 /// GET /scrape/<key>
-fn scrape(tracker: Arc<TorrentTracker>) -> impl Filter<Extract = impl warp::Reply, Error = Rejection> + Clone {
+fn scrape(tracker: Arc<tracker::Tracker>) -> impl Filter<Extract = impl warp::Reply, Error = Rejection> + Clone {
     warp::path::path("scrape")
         .and(warp::filters::method::get())
         .and(with_scrape_request(tracker.config.on_reverse_proxy))

src/http/server.rs

@@ -2,17 +2,17 @@ use std::net::SocketAddr;
 use std::sync::Arc;
 
 use super::routes;
-use crate::tracker::TorrentTracker;
+use crate::tracker;
 
-/// Server that listens on HTTP, needs a `TorrentTracker`
+/// Server that listens on HTTP, needs a `tracker::TorrentTracker`
 #[derive(Clone)]
 pub struct Http {
-    tracker: Arc<TorrentTracker>,
+    tracker: Arc<tracker::Tracker>,
 }
 
 impl Http {
     #[must_use]
-    pub fn new(tracker: Arc<TorrentTracker>) -> Http {
+    pub fn new(tracker: Arc<tracker::Tracker>) -> Http {
         Http { tracker }
     }
 

src/jobs/http_tracker.rs

@@ -6,13 +6,13 @@ use tokio::task::JoinHandle;
 
 use crate::config::HttpTracker;
 use crate::http::server::Http;
-use crate::tracker::TorrentTracker;
+use crate::tracker;
 
 /// # Panics
 ///
 /// It would panic if the `config::HttpTracker` struct would contain an inappropriate values.
 #[must_use]
-pub fn start_job(config: &HttpTracker, tracker: Arc<TorrentTracker>) -> JoinHandle<()> {
+pub fn start_job(config: &HttpTracker, tracker: Arc<tracker::Tracker>) -> JoinHandle<()> {
     let bind_addr = config.bind_address.parse::<SocketAddr>().unwrap();
     let ssl_enabled = config.ssl_enabled;
     let ssl_cert_path = config.ssl_cert_path.clone();

src/jobs/torrent_cleanup.rs

@@ -5,10 +5,10 @@ use log::info;
 use tokio::task::JoinHandle;
 
 use crate::config::Configuration;
-use crate::tracker::TorrentTracker;
+use crate::tracker;
 
 #[must_use]
-pub fn start_job(config: &Configuration, tracker: &Arc<TorrentTracker>) -> JoinHandle<()> {
+pub fn start_job(config: &Configuration, tracker: &Arc<tracker::Tracker>) -> JoinHandle<()> {
     let weak_tracker = std::sync::Arc::downgrade(tracker);
     let interval = config.inactive_peer_cleanup_interval;
 

src/jobs/tracker_api.rs

@@ -6,12 +6,12 @@ use tokio::task::JoinHandle;
 
 use crate::api::server;
 use crate::config::Configuration;
-use crate::tracker::TorrentTracker;
+use crate::tracker;
 
 #[derive(Debug)]
 pub struct ApiServerJobStarted();
 
-pub async fn start_job(config: &Configuration, tracker: Arc<TorrentTracker>) -> JoinHandle<()> {
+pub async fn start_job(config: &Configuration, tracker: Arc<tracker::Tracker>) -> JoinHandle<()> {
     let bind_addr = config
         .http_api
         .bind_address

src/jobs/udp_tracker.rs

@@ -4,11 +4,11 @@ use log::{error, info, warn};
 use tokio::task::JoinHandle;
 
 use crate::config::UdpTracker;
-use crate::tracker::TorrentTracker;
+use crate::tracker;
 use crate::udp::server::UdpServer;
 
 #[must_use]
-pub fn start_job(config: &UdpTracker, tracker: Arc<TorrentTracker>) -> JoinHandle<()> {
+pub fn start_job(config: &UdpTracker, tracker: Arc<tracker::Tracker>) -> JoinHandle<()> {
     let bind_addr = config.bind_address.clone();
 
     tokio::spawn(async move {

src/main.rs

@@ -3,8 +3,7 @@ use std::sync::Arc;
 use log::info;
 use torrust_tracker::config::Configuration;
 use torrust_tracker::stats::setup_statistics;
-use torrust_tracker::tracker::TorrentTracker;
-use torrust_tracker::{ephemeral_instance_keys, logging, setup, static_time};
+use torrust_tracker::{ephemeral_instance_keys, logging, setup, static_time, tracker};
 
 #[tokio::main]
 async fn main() {
@@ -28,7 +27,7 @@ async fn main() {
     let (stats_event_sender, stats_repository) = setup_statistics(config.tracker_usage_statistics);
 
     // Initialize Torrust tracker
-    let tracker = match TorrentTracker::new(config.clone(), stats_event_sender, stats_repository) {
+    let tracker = match tracker::Tracker::new(&config.clone(), stats_event_sender, stats_repository) {
         Ok(tracker) => Arc::new(tracker),
         Err(error) => {
             panic!("{}", error)