refactor: [torrust#1298] remove dependency on global app container in packages

To be able to move more code from the main mod to workspace packages.

Packages cannot depend on global stuff.

Author: josecelano

packages/axum-http-tracker-server/src/container.rs

@@ -1,9 +1,15 @@
 use std::sync::Arc;
 
 use bittorrent_tracker_core::announce_handler::AnnounceHandler;
+use bittorrent_tracker_core::authentication::key::repository::in_memory::InMemoryKeyRepository;
 use bittorrent_tracker_core::authentication::service::AuthenticationService;
+use bittorrent_tracker_core::databases::setup::initialize_database;
 use bittorrent_tracker_core::scrape_handler::ScrapeHandler;
+use bittorrent_tracker_core::torrent::repository::in_memory::InMemoryTorrentRepository;
+use bittorrent_tracker_core::torrent::repository::persisted::DatabasePersistentTorrentRepository;
 use bittorrent_tracker_core::whitelist;
+use bittorrent_tracker_core::whitelist::authorization::WhitelistAuthorization;
+use bittorrent_tracker_core::whitelist::repository::in_memory::InMemoryWhitelist;
 use torrust_tracker_configuration::{Core, HttpTracker};
 
 pub struct HttpTrackerContainer {
@@ -15,3 +21,42 @@ pub struct HttpTrackerContainer {
     pub http_stats_event_sender: Arc<Option<Box<dyn bittorrent_http_tracker_core::statistics::event::sender::Sender>>>,
     pub authentication_service: Arc<AuthenticationService>,
 }
+
+#[must_use]
+pub fn initialize_http_tracker_container(
+    core_config: &Arc<Core>,
+    http_tracker_config: &Arc<HttpTracker>,
+) -> Arc<HttpTrackerContainer> {
+    // HTTP stats
+    let (http_stats_event_sender, _http_stats_repository) =
+        bittorrent_http_tracker_core::statistics::setup::factory(core_config.tracker_usage_statistics);
+    let http_stats_event_sender = Arc::new(http_stats_event_sender);
+
+    let database = initialize_database(core_config);
+    let in_memory_whitelist = Arc::new(InMemoryWhitelist::default());
+    let whitelist_authorization = Arc::new(WhitelistAuthorization::new(core_config, &in_memory_whitelist.clone()));
+    let in_memory_key_repository = Arc::new(InMemoryKeyRepository::default());
+    let authentication_service = Arc::new(AuthenticationService::new(core_config, &in_memory_key_repository));
+
+    let in_memory_torrent_repository = Arc::new(InMemoryTorrentRepository::default());
+    let db_torrent_repository = Arc::new(DatabasePersistentTorrentRepository::new(&database));
+
+    let announce_handler = Arc::new(AnnounceHandler::new(
+        core_config,
+        &whitelist_authorization,
+        &in_memory_torrent_repository,
+        &db_torrent_repository,
+    ));
+
+    let scrape_handler = Arc::new(ScrapeHandler::new(&whitelist_authorization, &in_memory_torrent_repository));
+
+    Arc::new(HttpTrackerContainer {
+        http_tracker_config: http_tracker_config.clone(),
+        core_config: core_config.clone(),
+        announce_handler: announce_handler.clone(),
+        scrape_handler: scrape_handler.clone(),
+        whitelist_authorization: whitelist_authorization.clone(),
+        http_stats_event_sender: http_stats_event_sender.clone(),
+        authentication_service: authentication_service.clone(),
+    })
+}

src/app.rs

@@ -29,7 +29,7 @@ use torrust_tracker_configuration::Configuration;
 use tracing::instrument;
 
 use crate::bootstrap::jobs::{health_check_api, http_tracker, torrent_cleanup, tracker_apis, udp_tracker};
-use crate::container::{AppContainer, HttpApiContainer, UdpTrackerContainer};
+use crate::container::AppContainer;
 use crate::servers;
 
 /// # Panics
@@ -79,7 +79,7 @@ pub async fn start(config: &Configuration, app_container: &Arc<AppContainer>) ->
                 );
             } else {
                 let udp_tracker_config = Arc::new(udp_tracker_config.clone());
-                let udp_tracker_container = Arc::new(UdpTrackerContainer::from_app_container(&udp_tracker_config, app_container));
+                let udp_tracker_container = Arc::new(app_container.udp_tracker_container(&udp_tracker_config));
 
                 jobs.push(udp_tracker::start_job(udp_tracker_container, registar.give_form()).await);
             }
@@ -111,7 +111,7 @@ pub async fn start(config: &Configuration, app_container: &Arc<AppContainer>) ->
     // Start HTTP API
     if let Some(http_api_config) = &config.http_api {
         let http_api_config = Arc::new(http_api_config.clone());
-        let http_api_container = Arc::new(HttpApiContainer::from_app_container(&http_api_config, app_container));
+        let http_api_container = Arc::new(app_container.http_api_container(&http_api_config));
 
         if let Some(job) = tracker_apis::start_job(http_api_container, registar.give_form(), servers::apis::Version::V1).await {
             jobs.push(job);

src/bootstrap/app.rs

@@ -33,11 +33,11 @@ use bittorrent_udp_tracker_core::MAX_CONNECTION_ID_ERRORS_PER_IP;
 use tokio::sync::RwLock;
 use torrust_tracker_clock::static_time;
 use torrust_tracker_configuration::validator::Validator;
-use torrust_tracker_configuration::{logging, Configuration, Logging};
+use torrust_tracker_configuration::{logging, Configuration, Core, HttpApi, Logging, UdpTracker};
 use tracing::instrument;
 
 use super::config::initialize_configuration;
-use crate::container::AppContainer;
+use crate::container::{AppContainer, HttpApiContainer, UdpTrackerContainer};
 
 /// It loads the configuration from the environment and builds app container.
 ///
@@ -155,6 +155,79 @@ pub fn initialize_app_container(configuration: &Configuration) -> AppContainer {
     }
 }
 
+#[must_use]
+pub fn initialize_http_api_container(core_config: &Arc<Core>, http_api_config: &Arc<HttpApi>) -> Arc<HttpApiContainer> {
+    // HTTP stats
+    let (_http_stats_event_sender, http_stats_repository) =
+        bittorrent_http_tracker_core::statistics::setup::factory(core_config.tracker_usage_statistics);
+    let http_stats_repository = Arc::new(http_stats_repository);
+
+    // UDP stats
+    let (_udp_stats_event_sender, udp_stats_repository) =
+        bittorrent_udp_tracker_core::statistics::setup::factory(core_config.tracker_usage_statistics);
+    let udp_stats_repository = Arc::new(udp_stats_repository);
+
+    let ban_service = Arc::new(RwLock::new(BanService::new(MAX_CONNECTION_ID_ERRORS_PER_IP)));
+    let database = initialize_database(core_config);
+    let in_memory_whitelist = Arc::new(InMemoryWhitelist::default());
+    let whitelist_manager = initialize_whitelist_manager(database.clone(), in_memory_whitelist.clone());
+    let db_key_repository = Arc::new(DatabaseKeyRepository::new(&database));
+    let in_memory_key_repository = Arc::new(InMemoryKeyRepository::default());
+    let keys_handler = Arc::new(KeysHandler::new(
+        &db_key_repository.clone(),
+        &in_memory_key_repository.clone(),
+    ));
+    let in_memory_torrent_repository = Arc::new(InMemoryTorrentRepository::default());
+
+    Arc::new(HttpApiContainer {
+        http_api_config: http_api_config.clone(),
+        core_config: core_config.clone(),
+        in_memory_torrent_repository: in_memory_torrent_repository.clone(),
+        keys_handler: keys_handler.clone(),
+        whitelist_manager: whitelist_manager.clone(),
+        ban_service: ban_service.clone(),
+        http_stats_repository: http_stats_repository.clone(),
+        udp_stats_repository: udp_stats_repository.clone(),
+    })
+}
+
+#[must_use]
+pub fn initialize_udt_tracker_container(
+    core_config: &Arc<Core>,
+    udp_tracker_config: &Arc<UdpTracker>,
+) -> Arc<UdpTrackerContainer> {
+    // UDP stats
+    let (udp_stats_event_sender, _udp_stats_repository) =
+        bittorrent_udp_tracker_core::statistics::setup::factory(core_config.tracker_usage_statistics);
+    let udp_stats_event_sender = Arc::new(udp_stats_event_sender);
+
+    let ban_service = Arc::new(RwLock::new(BanService::new(MAX_CONNECTION_ID_ERRORS_PER_IP)));
+    let database = initialize_database(core_config);
+    let in_memory_whitelist = Arc::new(InMemoryWhitelist::default());
+    let whitelist_authorization = Arc::new(WhitelistAuthorization::new(core_config, &in_memory_whitelist.clone()));
+    let in_memory_torrent_repository = Arc::new(InMemoryTorrentRepository::default());
+    let db_torrent_repository = Arc::new(DatabasePersistentTorrentRepository::new(&database));
+
+    let announce_handler = Arc::new(AnnounceHandler::new(
+        core_config,
+        &whitelist_authorization,
+        &in_memory_torrent_repository,
+        &db_torrent_repository,
+    ));
+
+    let scrape_handler = Arc::new(ScrapeHandler::new(&whitelist_authorization, &in_memory_torrent_repository));
+
+    Arc::new(UdpTrackerContainer {
+        udp_tracker_config: udp_tracker_config.clone(),
+        core_config: core_config.clone(),
+        announce_handler: announce_handler.clone(),
+        scrape_handler: scrape_handler.clone(),
+        whitelist_authorization: whitelist_authorization.clone(),
+        udp_stats_event_sender: udp_stats_event_sender.clone(),
+        ban_service: ban_service.clone(),
+    })
+}
+
 /// It initializes the application static values.
 ///
 /// These values are accessible throughout the entire application:

src/bootstrap/jobs/http_tracker.rs

@@ -77,24 +77,24 @@ async fn start_v1(
 mod tests {
     use std::sync::Arc;
 
+    use torrust_axum_http_tracker_server::container::initialize_http_tracker_container;
     use torrust_axum_http_tracker_server::Version;
     use torrust_server_lib::registar::Registar;
     use torrust_tracker_test_helpers::configuration::ephemeral_public;
 
-    use crate::bootstrap::app::{initialize_app_container, initialize_global_services};
+    use crate::bootstrap::app::initialize_global_services;
     use crate::bootstrap::jobs::http_tracker::start_job;
 
     #[tokio::test]
     async fn it_should_start_http_tracker() {
         let cfg = Arc::new(ephemeral_public());
+        let core_config = Arc::new(cfg.core.clone());
         let http_tracker = cfg.http_trackers.clone().expect("missing HTTP tracker configuration");
         let http_tracker_config = Arc::new(http_tracker[0].clone());
 
         initialize_global_services(&cfg);
 
-        let app_container = Arc::new(initialize_app_container(&cfg));
-
-        let http_tracker_container = Arc::new(app_container.http_tracker_container(&http_tracker_config));
+        let http_tracker_container = initialize_http_tracker_container(&core_config, &http_tracker_config);
 
         let version = Version::V1;
 

src/bootstrap/jobs/tracker_apis.rs

@@ -100,21 +100,19 @@ mod tests {
     use torrust_server_lib::registar::Registar;
     use torrust_tracker_test_helpers::configuration::ephemeral_public;
 
-    use crate::bootstrap::app::{initialize_app_container, initialize_global_services};
+    use crate::bootstrap::app::{initialize_global_services, initialize_http_api_container};
     use crate::bootstrap::jobs::tracker_apis::start_job;
-    use crate::container::HttpApiContainer;
     use crate::servers::apis::Version;
 
     #[tokio::test]
     async fn it_should_start_http_tracker() {
         let cfg = Arc::new(ephemeral_public());
+        let core_config = Arc::new(cfg.core.clone());
         let http_api_config = Arc::new(cfg.http_api.clone().unwrap());
 
         initialize_global_services(&cfg);
 
-        let app_container = Arc::new(initialize_app_container(&cfg));
-
-        let http_api_container = Arc::new(HttpApiContainer::from_app_container(&http_api_config, &app_container));
+        let http_api_container = initialize_http_api_container(&core_config, &http_api_config);
 
         let version = Version::V1;
 

src/container.rs

@@ -50,6 +50,33 @@ impl AppContainer {
             authentication_service: self.authentication_service.clone(),
         }
     }
+
+    #[must_use]
+    pub fn udp_tracker_container(&self, udp_tracker_config: &Arc<UdpTracker>) -> UdpTrackerContainer {
+        UdpTrackerContainer {
+            udp_tracker_config: udp_tracker_config.clone(),
+            core_config: self.core_config.clone(),
+            announce_handler: self.announce_handler.clone(),
+            scrape_handler: self.scrape_handler.clone(),
+            whitelist_authorization: self.whitelist_authorization.clone(),
+            udp_stats_event_sender: self.udp_stats_event_sender.clone(),
+            ban_service: self.ban_service.clone(),
+        }
+    }
+
+    #[must_use]
+    pub fn http_api_container(&self, http_api_config: &Arc<HttpApi>) -> HttpApiContainer {
+        HttpApiContainer {
+            http_api_config: http_api_config.clone(),
+            core_config: self.core_config.clone(),
+            in_memory_torrent_repository: self.in_memory_torrent_repository.clone(),
+            keys_handler: self.keys_handler.clone(),
+            whitelist_manager: self.whitelist_manager.clone(),
+            ban_service: self.ban_service.clone(),
+            http_stats_repository: self.http_stats_repository.clone(),
+            udp_stats_repository: self.udp_stats_repository.clone(),
+        }
+    }
 }
 
 pub struct UdpTrackerContainer {
@@ -62,21 +89,6 @@ pub struct UdpTrackerContainer {
     pub ban_service: Arc<RwLock<BanService>>,
 }
 
-impl UdpTrackerContainer {
-    #[must_use]
-    pub fn from_app_container(udp_tracker_config: &Arc<UdpTracker>, app_container: &Arc<AppContainer>) -> Self {
-        Self {
-            udp_tracker_config: udp_tracker_config.clone(),
-            core_config: app_container.core_config.clone(),
-            announce_handler: app_container.announce_handler.clone(),
-            scrape_handler: app_container.scrape_handler.clone(),
-            whitelist_authorization: app_container.whitelist_authorization.clone(),
-            udp_stats_event_sender: app_container.udp_stats_event_sender.clone(),
-            ban_service: app_container.ban_service.clone(),
-        }
-    }
-}
-
 pub struct HttpApiContainer {
     pub core_config: Arc<Core>,
     pub http_api_config: Arc<HttpApi>,
@@ -87,19 +99,3 @@ pub struct HttpApiContainer {
     pub http_stats_repository: Arc<bittorrent_http_tracker_core::statistics::repository::Repository>,
     pub udp_stats_repository: Arc<bittorrent_udp_tracker_core::statistics::repository::Repository>,
 }
-
-impl HttpApiContainer {
-    #[must_use]
-    pub fn from_app_container(http_api_config: &Arc<HttpApi>, app_container: &Arc<AppContainer>) -> Self {
-        Self {
-            http_api_config: http_api_config.clone(),
-            core_config: app_container.core_config.clone(),
-            in_memory_torrent_repository: app_container.in_memory_torrent_repository.clone(),
-            keys_handler: app_container.keys_handler.clone(),
-            whitelist_manager: app_container.whitelist_manager.clone(),
-            ban_service: app_container.ban_service.clone(),
-            http_stats_repository: app_container.http_stats_repository.clone(),
-            udp_stats_repository: app_container.udp_stats_repository.clone(),
-        }
-    }
-}

src/servers/apis/server.rs

@@ -298,19 +298,17 @@ mod tests {
     use torrust_server_lib::registar::Registar;
     use torrust_tracker_test_helpers::configuration::ephemeral_public;
 
-    use crate::bootstrap::app::{initialize_app_container, initialize_global_services};
-    use crate::container::HttpApiContainer;
+    use crate::bootstrap::app::{initialize_global_services, initialize_http_api_container};
     use crate::servers::apis::server::{ApiServer, Launcher};
 
     #[tokio::test]
     async fn it_should_be_able_to_start_and_stop() {
         let cfg = Arc::new(ephemeral_public());
+        let core_config = Arc::new(cfg.core.clone());
         let http_api_config = Arc::new(cfg.http_api.clone().unwrap());
 
         initialize_global_services(&cfg);
 
-        let app_container = Arc::new(initialize_app_container(&cfg));
-
         let bind_to = http_api_config.bind_address;
 
         let tls = make_rust_tls(&http_api_config.tsl_config)
@@ -323,7 +321,7 @@ mod tests {
 
         let register = &Registar::default();
 
-        let http_api_container = Arc::new(HttpApiContainer::from_app_container(&http_api_config, &app_container));
+        let http_api_container = initialize_http_api_container(&core_config, &http_api_config);
 
         let started = stopped
             .start(http_api_container, register.give_form(), access_tokens)