Refactor TrackerService to improve app testability

src/app.rs

@@ -14,7 +14,8 @@ use crate::config::Configuration;
 use crate::databases::database::connect_database;
 use crate::mailer::MailerService;
 use crate::routes;
-use crate::tracker::TrackerService;
+use crate::tracker::service::Service;
+use crate::tracker::statistics_importer::StatisticsImporter;
 
 pub struct Running {
     pub api_server: Server,
@@ -44,7 +45,9 @@ pub async fn run(configuration: Configuration) -> Running {
 
     let database = Arc::new(connect_database(&database_connect_url).await.expect("Database error."));
     let auth = Arc::new(AuthorizationService::new(cfg.clone(), database.clone()));
-    let tracker_service = Arc::new(TrackerService::new(cfg.clone(), database.clone()));
+    let tracker_service = Arc::new(Service::new(cfg.clone(), database.clone()).await);
+    let tracker_statistics_importer =
+        Arc::new(StatisticsImporter::new(cfg.clone(), tracker_service.clone(), database.clone()).await);
     let mailer_service = Arc::new(MailerService::new(cfg.clone()).await);
     let image_cache_service = Arc::new(ImageCacheService::new(cfg.clone()).await);
 
@@ -55,23 +58,24 @@ pub async fn run(configuration: Configuration) -> Running {
         database.clone(),
         auth.clone(),
         tracker_service.clone(),
+        tracker_statistics_importer.clone(),
         mailer_service,
         image_cache_service,
     ));
 
     // Start repeating task to import tracker torrent data and updating
     // seeders and leechers info.
 
-    let weak_tracker_service = Arc::downgrade(&tracker_service);
+    let weak_tracker_statistics_importer = Arc::downgrade(&tracker_statistics_importer);
 
-    let tracker_data_importer_handle = tokio::spawn(async move {
+    let tracker_statistics_importer_handle = tokio::spawn(async move {
         let interval = std::time::Duration::from_secs(database_torrent_info_update_interval);
         let mut interval = tokio::time::interval(interval);
         interval.tick().await; // first tick is immediate...
         loop {
             interval.tick().await;
-            if let Some(tracker) = weak_tracker_service.upgrade() {
-                let _ = tracker.update_torrents().await;
+            if let Some(tracker) = weak_tracker_statistics_importer.upgrade() {
+                let _ = tracker.import_all_torrents_statistics().await;
             } else {
                 break;
             }
@@ -105,6 +109,6 @@ pub async fn run(configuration: Configuration) -> Running {
     Running {
         api_server: running_server,
         socket_address,
-        tracker_data_importer_handle,
+        tracker_data_importer_handle: tracker_statistics_importer_handle,
     }
 }

src/common.rs

@@ -5,7 +5,8 @@ use crate::cache::image::manager::ImageCacheService;
 use crate::config::Configuration;
 use crate::databases::database::Database;
 use crate::mailer::MailerService;
-use crate::tracker::TrackerService;
+use crate::tracker::service::Service;
+use crate::tracker::statistics_importer::StatisticsImporter;
 
 pub type Username = String;
 
@@ -15,7 +16,8 @@ pub struct AppData {
     pub cfg: Arc<Configuration>,
     pub database: Arc<Box<dyn Database>>,
     pub auth: Arc<AuthorizationService>,
-    pub tracker: Arc<TrackerService>,
+    pub tracker_service: Arc<Service>,
+    pub tracker_statistics_importer: Arc<StatisticsImporter>,
     pub mailer: Arc<MailerService>,
     pub image_cache_manager: Arc<ImageCacheService>,
 }
@@ -25,15 +27,17 @@ impl AppData {
         cfg: Arc<Configuration>,
         database: Arc<Box<dyn Database>>,
         auth: Arc<AuthorizationService>,
-        tracker: Arc<TrackerService>,
+        tracker_service: Arc<Service>,
+        tracker_statistics_importer: Arc<StatisticsImporter>,
         mailer: Arc<MailerService>,
         image_cache_manager: Arc<ImageCacheService>,
     ) -> AppData {
         AppData {
             cfg,
             database,
             auth,
-            tracker,
+            tracker_service,
+            tracker_statistics_importer,
             mailer,
             image_cache_manager,
         }

src/console/commands/import_tracker_statistics.rs

@@ -9,7 +9,8 @@ use text_colorizer::*;
 use crate::bootstrap::config::init_configuration;
 use crate::bootstrap::logging;
 use crate::databases::database::connect_database;
-use crate::tracker::TrackerService;
+use crate::tracker::service::Service;
+use crate::tracker::statistics_importer::StatisticsImporter;
 
 const NUMBER_OF_ARGUMENTS: usize = 0;
 
@@ -76,7 +77,9 @@ pub async fn import(_args: &Arguments) {
             .expect("Database error."),
     );
 
-    let tracker_service = Arc::new(TrackerService::new(cfg.clone(), database.clone()));
+    let tracker_service = Arc::new(Service::new(cfg.clone(), database.clone()).await);
+    let tracker_statistics_importer =
+        Arc::new(StatisticsImporter::new(cfg.clone(), tracker_service.clone(), database.clone()).await);
 
-    tracker_service.update_torrents().await.unwrap();
+    tracker_statistics_importer.import_all_torrents_statistics().await.unwrap();
 }

src/routes/torrent.rs

@@ -100,15 +100,15 @@ pub async fn upload_torrent(req: HttpRequest, payload: Multipart, app_data: WebA
 
     // update torrent tracker stats
     let _ = app_data
-        .tracker
-        .update_torrent_tracker_stats(torrent_id, &torrent_request.torrent.info_hash())
+        .tracker_statistics_importer
+        .import_torrent_statistics(torrent_id, &torrent_request.torrent.info_hash())
         .await;
 
     // whitelist info hash on tracker
     // code-review: why do we always try to whitelist the torrent on the tracker?
     // shouldn't we only do this if the torrent is in "Listed" mode?
     if let Err(e) = app_data
-        .tracker
+        .tracker_service
         .whitelist_info_hash(torrent_request.torrent.info_hash())
         .await
     {
@@ -146,7 +146,7 @@ pub async fn download_torrent_handler(req: HttpRequest, app_data: WebAppData) ->
     match user {
         Ok(user) => {
             let personal_announce_url = app_data
-                .tracker
+                .tracker_service
                 .get_personal_announce_url(user.user_id)
                 .await
                 .unwrap_or(tracker_url);
@@ -210,7 +210,7 @@ pub async fn get_torrent_handler(req: HttpRequest, app_data: WebAppData) -> Serv
         Ok(user) => {
             // if no user owned tracker key can be found, use default tracker url
             let personal_announce_url = app_data
-                .tracker
+                .tracker_service
                 .get_personal_announce_url(user.user_id)
                 .await
                 .unwrap_or(tracker_url);
@@ -240,8 +240,8 @@ pub async fn get_torrent_handler(req: HttpRequest, app_data: WebAppData) -> Serv
 
     // get realtime seeders and leechers
     if let Ok(torrent_info) = app_data
-        .tracker
-        .get_torrent_info(torrent_response.torrent_id, &torrent_response.info_hash)
+        .tracker_statistics_importer
+        .import_torrent_statistics(torrent_response.torrent_id, &torrent_response.info_hash)
         .await
     {
         torrent_response.seeders = torrent_info.seeders;
@@ -310,7 +310,7 @@ pub async fn delete_torrent_handler(req: HttpRequest, app_data: WebAppData) -> S
 
     // remove info_hash from tracker whitelist
     let _ = app_data
-        .tracker
+        .tracker_service
         .remove_info_hash_from_whitelist(torrent_listing.info_hash)
         .await;