Merge #1475: Refactor app bootstrapping

d80bfc0 refactor: extract functions in app start (Jose Celano)
56c3bd1 refactor: update logs messages (Jose Celano)
00e43ca refactor: move Registar to AppContainer (Jose Celano)

Pull request description:

  Refactor app bootstrapping before implementing #1444:

  - [x] Move `Registar` to `AppContainer`.
  - [x] Extract functions in the `start` function.

ACKs for top commit:
  josecelano:
    ACK d80bfc0

Tree-SHA512: c42789adc2236fe67f6dfdf9526abfd03ffdf9a97ebeaf38e41ecd07d5c6e0d12a80f3e4124d575b6dc9bcef7471993ed9a3527d7f5e4e327e5c706605b07322

Author: josecelano

src/app.rs

@@ -24,44 +24,67 @@
 use std::sync::Arc;
 
 use tokio::task::JoinHandle;
-use torrust_server_lib::registar::Registar;
-use torrust_tracker_configuration::Configuration;
+use torrust_tracker_configuration::{Configuration, HttpTracker, UdpTracker};
 use tracing::instrument;
 
-use crate::bootstrap;
 use crate::bootstrap::jobs::{health_check_api, http_tracker, torrent_cleanup, tracker_apis, udp_tracker};
+use crate::bootstrap::{self};
 use crate::container::AppContainer;
 
-pub async fn run() -> (Arc<AppContainer>, Vec<JoinHandle<()>>, Registar) {
+pub async fn run() -> (Arc<AppContainer>, Vec<JoinHandle<()>>) {
     let (config, app_container) = bootstrap::app::setup();
 
     let app_container = Arc::new(app_container);
 
-    let (jobs, registar) = start(&config, &app_container).await;
+    let jobs = start(&config, &app_container).await;
 
-    (app_container, jobs, registar)
+    (app_container, jobs)
 }
 
+/// Starts the tracker application.
+///
 /// # Panics
 ///
 /// Will panic if:
 ///
 /// - Can't retrieve tracker keys from database.
 /// - Can't load whitelist from database.
 #[instrument(skip(config, app_container))]
-pub async fn start(config: &Configuration, app_container: &Arc<AppContainer>) -> (Vec<JoinHandle<()>>, Registar) {
+pub async fn start(config: &Configuration, app_container: &Arc<AppContainer>) -> Vec<JoinHandle<()>> {
+    warn_if_no_services_enabled(config);
+
+    load_data_from_database(config, app_container).await;
+
+    start_jobs(config, app_container).await
+}
+
+async fn load_data_from_database(config: &Configuration, app_container: &Arc<AppContainer>) {
+    load_peer_keys(config, app_container).await;
+    load_whitelisted_torrents(config, app_container).await;
+}
+
+async fn start_jobs(config: &Configuration, app_container: &Arc<AppContainer>) -> Vec<JoinHandle<()>> {
+    let mut jobs: Vec<JoinHandle<()>> = Vec::new();
+
+    start_the_udp_instances(config, app_container, &mut jobs).await;
+    start_the_http_instances(config, app_container, &mut jobs).await;
+    start_the_http_api(config, app_container, &mut jobs).await;
+    start_torrent_cleanup(config, app_container, &mut jobs);
+    start_health_check_api(config, app_container, &mut jobs).await;
+
+    jobs
+}
+
+fn warn_if_no_services_enabled(config: &Configuration) {
     if config.http_api.is_none()
         && (config.udp_trackers.is_none() || config.udp_trackers.as_ref().map_or(true, std::vec::Vec::is_empty))
         && (config.http_trackers.is_none() || config.http_trackers.as_ref().map_or(true, std::vec::Vec::is_empty))
     {
         tracing::warn!("No services enabled in configuration");
     }
+}
 
-    let mut jobs: Vec<JoinHandle<()>> = Vec::new();
-
-    let registar = Registar::default();
-
-    // Load peer keys
+async fn load_peer_keys(config: &Configuration, app_container: &Arc<AppContainer>) {
     if config.core.private {
         app_container
             .tracker_core_container
@@ -70,8 +93,9 @@ pub async fn start(config: &Configuration, app_container: &Arc<AppContainer>) ->
             .await
             .expect("Could not retrieve keys from database.");
     }
+}
 
-    // Load whitelisted torrents
+async fn load_whitelisted_torrents(config: &Configuration, app_container: &Arc<AppContainer>) {
     if config.core.listed {
         app_container
             .tracker_core_container
@@ -80,8 +104,9 @@ pub async fn start(config: &Configuration, app_container: &Arc<AppContainer>) ->
             .await
             .expect("Could not load whitelist from database.");
     }
+}
 
-    // Start the UDP blocks
+async fn start_the_udp_instances(config: &Configuration, app_container: &Arc<AppContainer>, jobs: &mut Vec<JoinHandle<()>>) {
     if let Some(udp_trackers) = &config.udp_trackers {
         for udp_tracker_config in udp_trackers {
             if config.core.private {
@@ -90,49 +115,68 @@ pub async fn start(config: &Configuration, app_container: &Arc<AppContainer>) ->
                     udp_tracker_config.bind_address
                 );
             } else {
-                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,
-                );
+                start_udp_instance(udp_tracker_config, app_container, jobs).await;
             }
         }
     } else {
         tracing::info!("No UDP blocks in configuration");
     }
+}
 
-    // Start the HTTP blocks
+async fn start_udp_instance(udp_tracker_config: &UdpTracker, app_container: &Arc<AppContainer>, jobs: &mut Vec<JoinHandle<()>>) {
+    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,
+            app_container.registar.give_form(),
+        )
+        .await,
+    );
+}
+
+async fn start_the_http_instances(config: &Configuration, app_container: &Arc<AppContainer>, jobs: &mut Vec<JoinHandle<()>>) {
     if let Some(http_trackers) = &config.http_trackers {
         for http_tracker_config in http_trackers {
-            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,
-                registar.give_form(),
-                torrust_axum_http_tracker_server::Version::V1,
-            )
-            .await
-            {
-                jobs.push(job);
-            }
+            start_http_instance(http_tracker_config, app_container, jobs).await;
         }
     } else {
         tracing::info!("No HTTP blocks in configuration");
     }
+}
+
+async fn start_http_instance(
+    http_tracker_config: &HttpTracker,
+    app_container: &Arc<AppContainer>,
+    jobs: &mut Vec<JoinHandle<()>>,
+) {
+    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,
+        app_container.registar.give_form(),
+        torrust_axum_http_tracker_server::Version::V1,
+    )
+    .await
+    {
+        jobs.push(job);
+    }
+}
 
-    // Start HTTP API
+async fn start_the_http_api(config: &Configuration, app_container: &Arc<AppContainer>, jobs: &mut Vec<JoinHandle<()>>) {
     if let Some(http_api_config) = &config.http_api {
         let http_api_config = Arc::new(http_api_config.clone());
         let http_api_container = app_container.tracker_http_api_container(&http_api_config);
 
         if let Some(job) = tracker_apis::start_job(
             http_api_container,
-            registar.give_form(),
+            app_container.registar.give_form(),
             torrust_axum_rest_tracker_api_server::Version::V1,
         )
         .await
@@ -142,17 +186,17 @@ pub async fn start(config: &Configuration, app_container: &Arc<AppContainer>) ->
     } else {
         tracing::info!("No API block in configuration");
     }
+}
 
-    // Start runners to remove torrents without peers, every interval
+fn start_torrent_cleanup(config: &Configuration, app_container: &Arc<AppContainer>, jobs: &mut Vec<JoinHandle<()>>) {
     if config.core.inactive_peer_cleanup_interval > 0 {
         jobs.push(torrent_cleanup::start_job(
             &config.core,
             &app_container.tracker_core_container.torrents_manager,
         ));
     }
+}
 
-    // Start Health Check API
-    jobs.push(health_check_api::start_job(&config.health_check_api, registar.entries()).await);
-
-    (jobs, registar)
+async fn start_health_check_api(config: &Configuration, app_container: &Arc<AppContainer>, jobs: &mut Vec<JoinHandle<()>>) {
+    jobs.push(health_check_api::start_job(&config.health_check_api, app_container.registar.entries()).await);
 }

src/console/profiling.rs

@@ -179,7 +179,7 @@ pub async fn run() {
         return;
     };
 
-    let (_app_container, jobs, _registar) = app::run().await;
+    let (_app_container, jobs) = app::run().await;
 
     // Run the tracker for a fixed duration
     let run_duration = sleep(Duration::from_secs(duration_secs));
@@ -189,7 +189,8 @@ pub async fn run() {
             tracing::info!("Torrust timed shutdown..");
         },
         _ = tokio::signal::ctrl_c() => {
-            tracing::info!("Torrust shutting down via Ctrl+C ...");
+            tracing::info!("Torrust tracker shutting down via Ctrl+C ...");
+
             // Await for all jobs to shutdown
             futures::future::join_all(jobs).await;
         }

src/container.rs

@@ -7,6 +7,7 @@ use bittorrent_tracker_core::container::TrackerCoreContainer;
 use bittorrent_udp_tracker_core::container::{UdpTrackerCoreContainer, UdpTrackerCoreServices};
 use bittorrent_udp_tracker_core::{self};
 use torrust_rest_tracker_api_core::container::TrackerHttpApiCoreContainer;
+use torrust_server_lib::registar::Registar;
 use torrust_tracker_configuration::{Configuration, HttpApi};
 use torrust_udp_tracker_server::container::UdpTrackerServerContainer;
 use tracing::instrument;
@@ -24,6 +25,9 @@ pub struct AppContainer {
     // Configuration
     pub http_api_config: Arc<Option<HttpApi>>,
 
+    // Registar
+    pub registar: Arc<Registar>,
+
     // Core
     pub tracker_core_container: Arc<TrackerCoreContainer>,
 
@@ -46,6 +50,10 @@ impl AppContainer {
 
         let http_api_config = Arc::new(configuration.http_api.clone());
 
+        // Registar
+
+        let registar = Arc::new(Registar::default());
+
         // Core
 
         let tracker_core_container = Arc::new(TrackerCoreContainer::initialize(&core_config));
@@ -73,6 +81,9 @@ impl AppContainer {
             // Configuration
             http_api_config,
 
+            // Registar
+            registar,
+
             // Core
             tracker_core_container,
 

src/main.rs

@@ -2,16 +2,17 @@ use torrust_tracker_lib::app;
 
 #[tokio::main]
 async fn main() {
-    let (_app_container, jobs, _registar) = app::run().await;
+    let (_app_container, jobs) = app::run().await;
 
     // handle the signals
     tokio::select! {
         _ = tokio::signal::ctrl_c() => {
-            tracing::info!("Torrust shutting down ...");
+            tracing::info!("Torrust tracker shutting down ...");
 
             // Await for all jobs to shutdown
             futures::future::join_all(jobs).await;
-            tracing::info!("Torrust successfully shutdown.");
+
+            tracing::info!("Torrust tracker successfully shutdown.");
         }
     }
 }

tests/servers/api/contract/stats/mod.rs

@@ -51,7 +51,7 @@ async fn the_stats_api_endpoint_should_return_the_global_stats() {
 
     env::set_var("TORRUST_TRACKER_CONFIG_TOML", config_with_two_http_trackers);
 
-    let (_app_container, _jobs, _registar) = app::run().await;
+    let (_app_container, _jobs) = app::run().await;
 
     announce_to_tracker("http://127.0.0.1:7272").await;
     announce_to_tracker("http://127.0.0.1:7373").await;