refactor: [torrust#1201] inject new extracted sercvies in core tracker

Author: josecelano

src/app_test.rs

@@ -9,6 +9,9 @@ use crate::core::authentication::key::repository::persisted::DatabaseKeyReposito
 use crate::core::authentication::service::{self, AuthenticationService};
 use crate::core::databases::Database;
 use crate::core::services::initialize_database;
+use crate::core::torrent::manager::TorrentsManager;
+use crate::core::torrent::repository::in_memory::InMemoryTorrentRepository;
+use crate::core::torrent::repository::persisted::DatabasePersistentTorrentRepository;
 use crate::core::whitelist;
 use crate::core::whitelist::repository::in_memory::InMemoryWhitelist;
 
@@ -22,6 +25,9 @@ pub fn initialize_tracker_dependencies(
     Arc<InMemoryWhitelist>,
     Arc<whitelist::authorization::Authorization>,
     Arc<AuthenticationService>,
+    Arc<InMemoryTorrentRepository>,
+    Arc<DatabasePersistentTorrentRepository>,
+    Arc<TorrentsManager>,
 ) {
     let database = initialize_database(config);
     let in_memory_whitelist = Arc::new(InMemoryWhitelist::default());
@@ -36,6 +42,21 @@ pub fn initialize_tracker_dependencies(
         &db_key_repository.clone(),
         &in_memory_key_repository.clone(),
     ));
+    let in_memory_torrent_repository = Arc::new(InMemoryTorrentRepository::default());
+    let db_torrent_repository = Arc::new(DatabasePersistentTorrentRepository::new(&database));
+    let torrents_manager = Arc::new(TorrentsManager::new(
+        &config.core,
+        &in_memory_torrent_repository,
+        &db_torrent_repository,
+    ));
 
-    (database, in_memory_whitelist, whitelist_authorization, authentication_service)
+    (
+        database,
+        in_memory_whitelist,
+        whitelist_authorization,
+        authentication_service,
+        in_memory_torrent_repository,
+        db_torrent_repository,
+        torrents_manager,
+    )
 }

src/bootstrap/app.rs

@@ -27,6 +27,9 @@ use crate::core::authentication::key::repository::in_memory::InMemoryKeyReposito
 use crate::core::authentication::key::repository::persisted::DatabaseKeyRepository;
 use crate::core::authentication::service;
 use crate::core::services::{initialize_database, initialize_tracker, initialize_whitelist_manager, statistics};
+use crate::core::torrent::manager::TorrentsManager;
+use crate::core::torrent::repository::in_memory::InMemoryTorrentRepository;
+use crate::core::torrent::repository::persisted::DatabasePersistentTorrentRepository;
 use crate::core::whitelist;
 use crate::core::whitelist::repository::in_memory::InMemoryWhitelist;
 use crate::servers::udp::server::banning::BanService;
@@ -103,8 +106,22 @@ pub fn initialize_app_container(configuration: &Configuration) -> AppContainer {
         &db_key_repository.clone(),
         &in_memory_key_repository.clone(),
     ));
+    let in_memory_torrent_repository = Arc::new(InMemoryTorrentRepository::default());
+    let db_torrent_repository = Arc::new(DatabasePersistentTorrentRepository::new(&database));
+    let torrents_manager = Arc::new(TorrentsManager::new(
+        &configuration.core,
+        &in_memory_torrent_repository,
+        &db_torrent_repository,
+    ));
 
-    let tracker = Arc::new(initialize_tracker(configuration, &database, &whitelist_authorization));
+    let tracker = Arc::new(initialize_tracker(
+        configuration,
+        &database,
+        &whitelist_authorization,
+        &in_memory_torrent_repository,
+        &db_torrent_repository,
+        &torrents_manager,
+    ));
 
     AppContainer {
         tracker,

src/core/mod.rs

@@ -546,21 +546,17 @@ impl Tracker {
         config: &Core,
         database: &Arc<Box<dyn Database>>,
         whitelist_authorization: &Arc<whitelist::authorization::Authorization>,
+        in_memory_torrent_repository: &Arc<InMemoryTorrentRepository>,
+        db_torrent_repository: &Arc<DatabasePersistentTorrentRepository>,
+        torrents_manager: &Arc<TorrentsManager>,
     ) -> Result<Tracker, databases::error::Error> {
-        let in_memory_torrent_repository = Arc::new(InMemoryTorrentRepository::default());
-        let db_torrent_repository = Arc::new(DatabasePersistentTorrentRepository::new(database));
-
         Ok(Tracker {
             config: config.clone(),
             database: database.clone(),
             whitelist_authorization: whitelist_authorization.clone(),
             in_memory_torrent_repository: in_memory_torrent_repository.clone(),
             db_torrent_repository: db_torrent_repository.clone(),
-            torrents_manager: Arc::new(TorrentsManager::new(
-                config,
-                &in_memory_torrent_repository,
-                &db_torrent_repository,
-            )),
+            torrents_manager: torrents_manager.clone(),
         })
     }
 
@@ -802,21 +798,49 @@ mod tests {
         fn public_tracker() -> Tracker {
             let config = configuration::ephemeral_public();
 
-            let (database, _in_memory_whitelist, whitelist_authorization, _authentication_service) =
-                initialize_tracker_dependencies(&config);
-
-            initialize_tracker(&config, &database, &whitelist_authorization)
+            let (
+                database,
+                _in_memory_whitelist,
+                whitelist_authorization,
+                _authentication_service,
+                in_memory_torrent_repository,
+                db_torrent_repository,
+                torrents_manager,
+            ) = initialize_tracker_dependencies(&config);
+
+            initialize_tracker(
+                &config,
+                &database,
+                &whitelist_authorization,
+                &in_memory_torrent_repository,
+                &db_torrent_repository,
+                &torrents_manager,
+            )
         }
 
         fn whitelisted_tracker() -> (Tracker, Arc<whitelist::authorization::Authorization>, Arc<WhiteListManager>) {
             let config = configuration::ephemeral_listed();
 
-            let (database, in_memory_whitelist, whitelist_authorization, _authentication_service) =
-                initialize_tracker_dependencies(&config);
+            let (
+                database,
+                in_memory_whitelist,
+                whitelist_authorization,
+                _authentication_service,
+                in_memory_torrent_repository,
+                db_torrent_repository,
+                torrents_manager,
+            ) = initialize_tracker_dependencies(&config);
 
             let whitelist_manager = initialize_whitelist_manager(database.clone(), in_memory_whitelist.clone());
 
-            let tracker = initialize_tracker(&config, &database, &whitelist_authorization);
+            let tracker = initialize_tracker(
+                &config,
+                &database,
+                &whitelist_authorization,
+                &in_memory_torrent_repository,
+                &db_torrent_repository,
+                &torrents_manager,
+            );
 
             (tracker, whitelist_authorization, whitelist_manager)
         }
@@ -825,10 +849,24 @@ mod tests {
             let mut config = configuration::ephemeral_listed();
             config.core.tracker_policy.persistent_torrent_completed_stat = true;
 
-            let (database, _in_memory_whitelist, whitelist_authorization, _authentication_service) =
-                initialize_tracker_dependencies(&config);
-
-            initialize_tracker(&config, &database, &whitelist_authorization)
+            let (
+                database,
+                _in_memory_whitelist,
+                whitelist_authorization,
+                _authentication_service,
+                in_memory_torrent_repository,
+                db_torrent_repository,
+                torrents_manager,
+            ) = initialize_tracker_dependencies(&config);
+
+            initialize_tracker(
+                &config,
+                &database,
+                &whitelist_authorization,
+                &in_memory_torrent_repository,
+                &db_torrent_repository,
+                &torrents_manager,
+            )
         }
 
         fn sample_info_hash() -> InfoHash {

src/core/services/mod.rs

@@ -14,6 +14,9 @@ use torrust_tracker_configuration::v2_0_0::database;
 use torrust_tracker_configuration::Configuration;
 
 use super::databases::{self, Database};
+use super::torrent::manager::TorrentsManager;
+use super::torrent::repository::in_memory::InMemoryTorrentRepository;
+use super::torrent::repository::persisted::DatabasePersistentTorrentRepository;
 use super::whitelist;
 use super::whitelist::manager::WhiteListManager;
 use super::whitelist::repository::in_memory::InMemoryWhitelist;
@@ -30,8 +33,18 @@ pub fn initialize_tracker(
     config: &Configuration,
     database: &Arc<Box<dyn Database>>,
     whitelist_authorization: &Arc<whitelist::authorization::Authorization>,
+    in_memory_torrent_repository: &Arc<InMemoryTorrentRepository>,
+    db_torrent_repository: &Arc<DatabasePersistentTorrentRepository>,
+    torrents_manager: &Arc<TorrentsManager>,
 ) -> Tracker {
-    match Tracker::new(&Arc::new(config).core, database, whitelist_authorization) {
+    match Tracker::new(
+        &Arc::new(config).core,
+        database,
+        whitelist_authorization,
+        in_memory_torrent_repository,
+        db_torrent_repository,
+        torrents_manager,
+    ) {
         Ok(tracker) => tracker,
         Err(error) => {
             panic!("{}", error)

src/core/services/statistics/mod.rs

@@ -132,12 +132,27 @@ mod tests {
     async fn the_statistics_service_should_return_the_tracker_metrics() {
         let config = tracker_configuration();
 
-        let (database, _in_memory_whitelist, whitelist_authorization, _authentication_service) =
-            initialize_tracker_dependencies(&config);
+        let (
+            database,
+            _in_memory_whitelist,
+            whitelist_authorization,
+            _authentication_service,
+            in_memory_torrent_repository,
+            db_torrent_repository,
+            torrents_manager,
+        ) = initialize_tracker_dependencies(&config);
+
         let (_stats_event_sender, stats_repository) = statistics::setup::factory(config.core.tracker_usage_statistics);
         let stats_repository = Arc::new(stats_repository);
 
-        let tracker = Arc::new(initialize_tracker(&config, &database, &whitelist_authorization));
+        let tracker = Arc::new(initialize_tracker(
+            &config,
+            &database,
+            &whitelist_authorization,
+            &in_memory_torrent_repository,
+            &db_torrent_repository,
+            &torrents_manager,
+        ));
 
         let ban_service = Arc::new(RwLock::new(BanService::new(MAX_CONNECTION_ID_ERRORS_PER_IP)));