Merge #1412: Refactor: AppContainer to initialize all services in the setup phase

299d0f3 refactor: [#1411] extract static methods in AppContainer (Jose Celano)
ef5dc32 refactor: [#1411] reorganize fields in AppContainer (Jose Celano)
60ed2e4 refactor: [#1411] remove duplicate code for UdpTrackerServerServices initialization (Jose Celano)
4c7feb5 refactor: [#1411] remove duplicate code for UdpTrackerCoreServices initialization (Jose Celano)
fdf2055 refactor: [#1411] remove duplicate code for HttpTrackerCoreServices initialization (Jose Celano)
af80ada refactor: [#1411] store instance containers in app container (Jose Celano)

Pull request description:

  Refactor `AppContainer` to initialize all services in the setup phase.

  I've also removed duplicate code for services initialization.

  The REST API container is still initialized in the "start" phase because requires more changes to handle the optional value. We don't need it at the root level for now.

ACKs for top commit:
  josecelano:
    ACK 299d0f3

Tree-SHA512: 8e5e08725cdc3af0df76225962ff65a93eafab18cdb3d5339bcc4b4cd22791301f9a6c83172564e731c8df3c4334fbd6a9e3e0a4921ae037556f5c7f0009aaea

Author: josecelano

Cargo.lock

@@ -46,6 +46,7 @@ regex = "1"
 reqwest = { version = "0", features = ["json"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = { version = "1", features = ["preserve_order"] }
+thiserror = "2.0.12"
 tokio = { version = "1", features = ["macros", "net", "rt-multi-thread", "signal", "sync"] }
 torrust-axum-health-check-api-server = { version = "3.0.0-develop", path = "packages/axum-health-check-api-server" }
 torrust-axum-http-tracker-server = { version = "3.0.0-develop", path = "packages/axum-http-tracker-server" }

Cargo.toml

@@ -115,7 +115,8 @@ impl EnvContainer {
         let http_tracker_config = Arc::new(http_tracker_config[0].clone());
 
         let tracker_core_container = Arc::new(TrackerCoreContainer::initialize(&core_config));
-        let http_tracker_container = HttpTrackerCoreContainer::initialize_from(&tracker_core_container, &http_tracker_config);
+        let http_tracker_container =
+            HttpTrackerCoreContainer::initialize_from_tracker_core(&tracker_core_container, &http_tracker_config);
 
         Self {
             tracker_core_container,

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

@@ -174,8 +174,9 @@ impl EnvContainer {
 
         let tracker_core_container = Arc::new(TrackerCoreContainer::initialize(&core_config));
         let http_tracker_core_container =
-            HttpTrackerCoreContainer::initialize_from(&tracker_core_container, &http_tracker_config);
-        let udp_tracker_core_container = UdpTrackerCoreContainer::initialize_from(&tracker_core_container, &udp_tracker_config);
+            HttpTrackerCoreContainer::initialize_from_tracker_core(&tracker_core_container, &http_tracker_config);
+        let udp_tracker_core_container =
+            UdpTrackerCoreContainer::initialize_from_tracker_core(&tracker_core_container, &udp_tracker_config);
         let udp_tracker_server_container = UdpTrackerServerContainer::initialize(&core_config);
 
         let tracker_http_api_core_container = TrackerHttpApiCoreContainer::initialize_from(

packages/axum-rest-tracker-api-server/src/environment.rs

@@ -5,11 +5,14 @@ use torrust_tracker_configuration::{Core, HttpTracker};
 
 use crate::services::announce::AnnounceService;
 use crate::services::scrape::ScrapeService;
-use crate::{event, statistics};
+use crate::{event, services, statistics};
 
 pub struct HttpTrackerCoreContainer {
-    pub tracker_core_container: Arc<TrackerCoreContainer>,
     pub http_tracker_config: Arc<HttpTracker>,
+
+    pub tracker_core_container: Arc<TrackerCoreContainer>,
+
+    // `HttpTrackerCoreServices`
     pub http_stats_event_sender: Arc<Option<Box<dyn event::sender::Sender>>>,
     pub http_stats_repository: Arc<statistics::repository::Repository>,
     pub announce_service: Arc<AnnounceService>,
@@ -20,41 +23,68 @@ impl HttpTrackerCoreContainer {
     #[must_use]
     pub fn initialize(core_config: &Arc<Core>, http_tracker_config: &Arc<HttpTracker>) -> Arc<Self> {
         let tracker_core_container = Arc::new(TrackerCoreContainer::initialize(core_config));
-        Self::initialize_from(&tracker_core_container, http_tracker_config)
+        Self::initialize_from_tracker_core(&tracker_core_container, http_tracker_config)
     }
 
     #[must_use]
-    pub fn initialize_from(
+    pub fn initialize_from_tracker_core(
         tracker_core_container: &Arc<TrackerCoreContainer>,
         http_tracker_config: &Arc<HttpTracker>,
     ) -> Arc<Self> {
+        let http_tracker_core_services = HttpTrackerCoreServices::initialize_from(tracker_core_container);
+        Self::initialize_from_services(tracker_core_container, &http_tracker_core_services, http_tracker_config)
+    }
+
+    #[must_use]
+    pub fn initialize_from_services(
+        tracker_core_container: &Arc<TrackerCoreContainer>,
+        http_tracker_core_services: &Arc<HttpTrackerCoreServices>,
+        http_tracker_config: &Arc<HttpTracker>,
+    ) -> Arc<Self> {
+        Arc::new(Self {
+            tracker_core_container: tracker_core_container.clone(),
+            http_tracker_config: http_tracker_config.clone(),
+            http_stats_event_sender: http_tracker_core_services.http_stats_event_sender.clone(),
+            http_stats_repository: http_tracker_core_services.http_stats_repository.clone(),
+            announce_service: http_tracker_core_services.http_announce_service.clone(),
+            scrape_service: http_tracker_core_services.http_scrape_service.clone(),
+        })
+    }
+}
+
+pub struct HttpTrackerCoreServices {
+    pub http_stats_event_sender: Arc<Option<Box<dyn event::sender::Sender>>>,
+    pub http_stats_repository: Arc<statistics::repository::Repository>,
+    pub http_announce_service: Arc<services::announce::AnnounceService>,
+    pub http_scrape_service: Arc<services::scrape::ScrapeService>,
+}
+
+impl HttpTrackerCoreServices {
+    #[must_use]
+    pub fn initialize_from(tracker_core_container: &Arc<TrackerCoreContainer>) -> Arc<Self> {
         let (http_stats_event_sender, http_stats_repository) =
             statistics::setup::factory(tracker_core_container.core_config.tracker_usage_statistics);
         let http_stats_event_sender = Arc::new(http_stats_event_sender);
         let http_stats_repository = Arc::new(http_stats_repository);
-
-        let announce_service = Arc::new(AnnounceService::new(
+        let http_announce_service = Arc::new(AnnounceService::new(
             tracker_core_container.core_config.clone(),
             tracker_core_container.announce_handler.clone(),
             tracker_core_container.authentication_service.clone(),
             tracker_core_container.whitelist_authorization.clone(),
             http_stats_event_sender.clone(),
         ));
-
-        let scrape_service = Arc::new(ScrapeService::new(
+        let http_scrape_service = Arc::new(ScrapeService::new(
             tracker_core_container.core_config.clone(),
             tracker_core_container.scrape_handler.clone(),
             tracker_core_container.authentication_service.clone(),
             http_stats_event_sender.clone(),
         ));
 
         Arc::new(Self {
-            tracker_core_container: tracker_core_container.clone(),
-            http_tracker_config: http_tracker_config.clone(),
-            http_stats_event_sender: http_stats_event_sender.clone(),
-            http_stats_repository: http_stats_repository.clone(),
-            announce_service: announce_service.clone(),
-            scrape_service: scrape_service.clone(),
+            http_stats_event_sender,
+            http_stats_repository,
+            http_announce_service,
+            http_scrape_service,
         })
     }
 }

packages/http-tracker-core/src/container.rs

@@ -10,12 +10,12 @@ use torrust_tracker_configuration::{Core, HttpApi, HttpTracker, UdpTracker};
 use torrust_udp_tracker_server::container::UdpTrackerServerContainer;
 
 pub struct TrackerHttpApiCoreContainer {
+    pub http_api_config: Arc<HttpApi>,
     pub tracker_core_container: Arc<TrackerCoreContainer>,
     pub http_stats_repository: Arc<bittorrent_http_tracker_core::statistics::repository::Repository>,
     pub ban_service: Arc<RwLock<BanService>>,
     pub udp_core_stats_repository: Arc<bittorrent_udp_tracker_core::statistics::repository::Repository>,
     pub udp_server_stats_repository: Arc<torrust_udp_tracker_server::statistics::repository::Repository>,
-    pub http_api_config: Arc<HttpApi>,
 }
 
 impl TrackerHttpApiCoreContainer {
@@ -27,8 +27,10 @@ impl TrackerHttpApiCoreContainer {
         http_api_config: &Arc<HttpApi>,
     ) -> Arc<TrackerHttpApiCoreContainer> {
         let tracker_core_container = Arc::new(TrackerCoreContainer::initialize(core_config));
-        let http_tracker_core_container = HttpTrackerCoreContainer::initialize_from(&tracker_core_container, http_tracker_config);
-        let udp_tracker_core_container = UdpTrackerCoreContainer::initialize_from(&tracker_core_container, udp_tracker_config);
+        let http_tracker_core_container =
+            HttpTrackerCoreContainer::initialize_from_tracker_core(&tracker_core_container, http_tracker_config);
+        let udp_tracker_core_container =
+            UdpTrackerCoreContainer::initialize_from_tracker_core(&tracker_core_container, udp_tracker_config);
         let udp_tracker_server_container = UdpTrackerServerContainer::initialize(core_config);
 
         Self::initialize_from(

packages/rest-tracker-api-core/src/container.rs

@@ -8,11 +8,14 @@ use crate::services::announce::AnnounceService;
 use crate::services::banning::BanService;
 use crate::services::connect::ConnectService;
 use crate::services::scrape::ScrapeService;
-use crate::{event, statistics, MAX_CONNECTION_ID_ERRORS_PER_IP};
+use crate::{event, services, statistics, MAX_CONNECTION_ID_ERRORS_PER_IP};
 
 pub struct UdpTrackerCoreContainer {
-    pub tracker_core_container: Arc<TrackerCoreContainer>,
     pub udp_tracker_config: Arc<UdpTracker>,
+
+    pub tracker_core_container: Arc<TrackerCoreContainer>,
+
+    // `UdpTrackerCoreServices`
     pub udp_core_stats_event_sender: Arc<Option<Box<dyn event::sender::Sender>>>,
     pub udp_core_stats_repository: Arc<statistics::repository::Repository>,
     pub ban_service: Arc<RwLock<BanService>>,
@@ -25,14 +28,52 @@ impl UdpTrackerCoreContainer {
     #[must_use]
     pub fn initialize(core_config: &Arc<Core>, udp_tracker_config: &Arc<UdpTracker>) -> Arc<UdpTrackerCoreContainer> {
         let tracker_core_container = Arc::new(TrackerCoreContainer::initialize(core_config));
-        Self::initialize_from(&tracker_core_container, udp_tracker_config)
+        Self::initialize_from_tracker_core(&tracker_core_container, udp_tracker_config)
     }
 
     #[must_use]
-    pub fn initialize_from(
+    pub fn initialize_from_tracker_core(
         tracker_core_container: &Arc<TrackerCoreContainer>,
         udp_tracker_config: &Arc<UdpTracker>,
     ) -> Arc<UdpTrackerCoreContainer> {
+        let udp_tracker_core_services = UdpTrackerCoreServices::initialize_from(tracker_core_container);
+        Self::initialize_from_services(tracker_core_container, &udp_tracker_core_services, udp_tracker_config)
+    }
+
+    #[must_use]
+    pub fn initialize_from_services(
+        tracker_core_container: &Arc<TrackerCoreContainer>,
+        udp_tracker_core_services: &Arc<UdpTrackerCoreServices>,
+        udp_tracker_config: &Arc<UdpTracker>,
+    ) -> Arc<Self> {
+        Arc::new(Self {
+            udp_tracker_config: udp_tracker_config.clone(),
+
+            tracker_core_container: tracker_core_container.clone(),
+
+            // `UdpTrackerCoreServices`
+            udp_core_stats_event_sender: udp_tracker_core_services.udp_core_stats_event_sender.clone(),
+            udp_core_stats_repository: udp_tracker_core_services.udp_core_stats_repository.clone(),
+            ban_service: udp_tracker_core_services.udp_ban_service.clone(),
+            connect_service: udp_tracker_core_services.udp_connect_service.clone(),
+            announce_service: udp_tracker_core_services.udp_announce_service.clone(),
+            scrape_service: udp_tracker_core_services.udp_scrape_service.clone(),
+        })
+    }
+}
+
+pub struct UdpTrackerCoreServices {
+    pub udp_core_stats_event_sender: Arc<Option<Box<dyn event::sender::Sender>>>,
+    pub udp_core_stats_repository: Arc<statistics::repository::Repository>,
+    pub udp_ban_service: Arc<RwLock<services::banning::BanService>>,
+    pub udp_connect_service: Arc<services::connect::ConnectService>,
+    pub udp_announce_service: Arc<services::announce::AnnounceService>,
+    pub udp_scrape_service: Arc<services::scrape::ScrapeService>,
+}
+
+impl UdpTrackerCoreServices {
+    #[must_use]
+    pub fn initialize_from(tracker_core_container: &Arc<TrackerCoreContainer>) -> Arc<Self> {
         let (udp_core_stats_event_sender, udp_core_stats_repository) =
             statistics::setup::factory(tracker_core_container.core_config.tracker_usage_statistics);
         let udp_core_stats_event_sender = Arc::new(udp_core_stats_event_sender);
@@ -49,15 +90,13 @@ impl UdpTrackerCoreContainer {
             udp_core_stats_event_sender.clone(),
         ));
 
-        Arc::new(UdpTrackerCoreContainer {
-            tracker_core_container: tracker_core_container.clone(),
-            udp_tracker_config: udp_tracker_config.clone(),
-            udp_core_stats_event_sender: udp_core_stats_event_sender.clone(),
-            udp_core_stats_repository: udp_core_stats_repository.clone(),
-            ban_service: ban_service.clone(),
-            connect_service: connect_service.clone(),
-            announce_service: announce_service.clone(),
-            scrape_service: scrape_service.clone(),
+        Arc::new(Self {
+            udp_core_stats_event_sender,
+            udp_core_stats_repository,
+            udp_ban_service: ban_service,
+            udp_connect_service: connect_service,
+            udp_announce_service: announce_service,
+            udp_scrape_service: scrape_service,
         })
     }
 }

packages/udp-tracker-core/src/container.rs

@@ -10,6 +10,23 @@ pub struct UdpTrackerServerContainer {
 }
 
 impl UdpTrackerServerContainer {
+    #[must_use]
+    pub fn initialize(core_config: &Arc<Core>) -> Arc<Self> {
+        let udp_tracker_server_services = UdpTrackerServerServices::initialize(core_config);
+
+        Arc::new(Self {
+            udp_server_stats_event_sender: udp_tracker_server_services.udp_server_stats_event_sender.clone(),
+            udp_server_stats_repository: udp_tracker_server_services.udp_server_stats_repository.clone(),
+        })
+    }
+}
+
+pub struct UdpTrackerServerServices {
+    pub udp_server_stats_event_sender: Arc<Option<Box<dyn event::sender::Sender>>>,
+    pub udp_server_stats_repository: Arc<statistics::repository::Repository>,
+}
+
+impl UdpTrackerServerServices {
     #[must_use]
     pub fn initialize(core_config: &Arc<Core>) -> Arc<Self> {
         let (udp_server_stats_event_sender, udp_server_stats_repository) =

packages/udp-tracker-server/src/container.rs

@@ -131,7 +131,8 @@ impl EnvContainer {
         let udp_tracker_config = Arc::new(udp_tracker_configurations[0].clone());
 
         let tracker_core_container = Arc::new(TrackerCoreContainer::initialize(&core_config));
-        let udp_tracker_core_container = UdpTrackerCoreContainer::initialize_from(&tracker_core_container, &udp_tracker_config);
+        let udp_tracker_core_container =
+            UdpTrackerCoreContainer::initialize_from_tracker_core(&tracker_core_container, &udp_tracker_config);
         let udp_tracker_server_container = UdpTrackerServerContainer::initialize(&core_config);
 
         Self {

packages/udp-tracker-server/src/environment.rs

@@ -90,9 +90,10 @@ pub async fn start(config: &Configuration, app_container: &Arc<AppContainer>) ->
                     udp_tracker_config.bind_address
                 );
             } else {
-                let udp_tracker_config = Arc::new(udp_tracker_config.clone());
-                let udp_tracker_container = Arc::new(app_container.udp_tracker_container(&udp_tracker_config));
-                let udp_tracker_server_container = Arc::new(app_container.udp_tracker_server_container());
+                let udp_tracker_container = app_container
+                    .udp_tracker_container(udp_tracker_config.bind_address)
+                    .expect("Could not create UDP tracker container");
+                let udp_tracker_server_container = app_container.udp_tracker_server_container();
 
                 jobs.push(
                     udp_tracker::start_job(udp_tracker_container, udp_tracker_server_container, registar.give_form()).await,
@@ -106,8 +107,9 @@ pub async fn start(config: &Configuration, app_container: &Arc<AppContainer>) ->
     // Start the HTTP blocks
     if let Some(http_trackers) = &config.http_trackers {
         for http_tracker_config in http_trackers {
-            let http_tracker_config = Arc::new(http_tracker_config.clone());
-            let http_tracker_container = Arc::new(app_container.http_tracker_container(&http_tracker_config));
+            let http_tracker_container = app_container
+                .http_tracker_container(http_tracker_config.bind_address)
+                .expect("Could not create HTTP tracker container");
 
             if let Some(job) = http_tracker::start_job(
                 http_tracker_container,
@@ -126,7 +128,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(app_container.tracker_http_api_container(&http_api_config));
+        let http_api_container = app_container.tracker_http_api_container(&http_api_config);
 
         if let Some(job) = tracker_apis::start_job(
             http_api_container,
@@ -149,8 +151,6 @@ pub async fn start(config: &Configuration, app_container: &Arc<AppContainer>) ->
         ));
     }
 
-    println!("Registar entries: {:?}", registar.entries());
-
     // Start Health Check API
     jobs.push(health_check_api::start_job(&config.health_check_api, registar.entries()).await);