Overhaul core Tracker: extract whitelist authorization

src/app.rs

@@ -61,7 +61,6 @@ pub async fn start(config: &Configuration, app_container: &AppContainer) -> Vec<
     // Load whitelisted torrents
     if app_container.tracker.is_listed() {
         app_container
-            .tracker
             .whitelist_manager
             .load_whitelist_from_database()
             .await
@@ -81,6 +80,7 @@ pub async fn start(config: &Configuration, app_container: &AppContainer) -> Vec<
                     udp_tracker::start_job(
                         udp_tracker_config,
                         app_container.tracker.clone(),
+                        app_container.whitelist_authorization.clone(),
                         app_container.stats_event_sender.clone(),
                         app_container.ban_service.clone(),
                         registar.give_form(),
@@ -99,6 +99,7 @@ pub async fn start(config: &Configuration, app_container: &AppContainer) -> Vec<
             if let Some(job) = http_tracker::start_job(
                 http_tracker_config,
                 app_container.tracker.clone(),
+                app_container.whitelist_authorization.clone(),
                 app_container.stats_event_sender.clone(),
                 registar.give_form(),
                 servers::http::Version::V1,
@@ -117,6 +118,7 @@ pub async fn start(config: &Configuration, app_container: &AppContainer) -> Vec<
         if let Some(job) = tracker_apis::start_job(
             http_api_config,
             app_container.tracker.clone(),
+            app_container.whitelist_manager.clone(),
             app_container.ban_service.clone(),
             app_container.stats_event_sender.clone(),
             app_container.stats_repository.clone(),

src/app_test.rs

@@ -4,15 +4,26 @@ use std::sync::Arc;
 use torrust_tracker_configuration::Configuration;
 
 use crate::core::databases::Database;
-use crate::core::services::{initialize_database, initialize_whitelist};
-use crate::core::whitelist::WhiteListManager;
+use crate::core::services::initialize_database;
+use crate::core::whitelist;
+use crate::core::whitelist::repository::in_memory::InMemoryWhitelist;
 
 /// Initialize the tracker dependencies.
 #[allow(clippy::type_complexity)]
 #[must_use]
-pub fn initialize_tracker_dependencies(config: &Configuration) -> (Arc<Box<dyn Database>>, Arc<WhiteListManager>) {
+pub fn initialize_tracker_dependencies(
+    config: &Configuration,
+) -> (
+    Arc<Box<dyn Database>>,
+    Arc<InMemoryWhitelist>,
+    Arc<whitelist::authorization::Authorization>,
+) {
     let database = initialize_database(config);
-    let whitelist_manager = initialize_whitelist(database.clone());
+    let in_memory_whitelist = Arc::new(InMemoryWhitelist::default());
+    let whitelist_authorization = Arc::new(whitelist::authorization::Authorization::new(
+        &config.core,
+        &in_memory_whitelist.clone(),
+    ));
 
-    (database, whitelist_manager)
+    (database, in_memory_whitelist, whitelist_authorization)
 }

src/bootstrap/app.rs

@@ -22,7 +22,9 @@ use tracing::instrument;
 use super::config::initialize_configuration;
 use crate::bootstrap;
 use crate::container::AppContainer;
-use crate::core::services::{initialize_database, initialize_tracker, initialize_whitelist, statistics};
+use crate::core::services::{initialize_database, initialize_tracker, initialize_whitelist_manager, statistics};
+use crate::core::whitelist;
+use crate::core::whitelist::repository::in_memory::InMemoryWhitelist;
 use crate::servers::udp::server::banning::BanService;
 use crate::servers::udp::server::launcher::MAX_CONNECTION_ID_ERRORS_PER_IP;
 use crate::shared::crypto::ephemeral_instance_keys;
@@ -81,11 +83,18 @@ pub fn initialize_app_container(configuration: &Configuration) -> AppContainer {
     let stats_repository = Arc::new(stats_repository);
     let ban_service = Arc::new(RwLock::new(BanService::new(MAX_CONNECTION_ID_ERRORS_PER_IP)));
     let database = initialize_database(configuration);
-    let whitelist_manager = initialize_whitelist(database.clone());
-    let tracker = Arc::new(initialize_tracker(configuration, &database, &whitelist_manager));
+    let in_memory_whitelist = Arc::new(InMemoryWhitelist::default());
+    let whitelist_authorization = Arc::new(whitelist::authorization::Authorization::new(
+        &configuration.core,
+        &in_memory_whitelist.clone(),
+    ));
+    let whitelist_manager = initialize_whitelist_manager(database.clone(), in_memory_whitelist.clone());
+
+    let tracker = Arc::new(initialize_tracker(configuration, &database, &whitelist_authorization));
 
     AppContainer {
         tracker,
+        whitelist_authorization,
         ban_service,
         stats_event_sender,
         stats_repository,

src/bootstrap/jobs/http_tracker.rs

@@ -20,7 +20,7 @@ use tracing::instrument;
 
 use super::make_rust_tls;
 use crate::core::statistics::event::sender::Sender;
-use crate::core::{self, statistics};
+use crate::core::{self, statistics, whitelist};
 use crate::servers::http::server::{HttpServer, Launcher};
 use crate::servers::http::Version;
 use crate::servers::registar::ServiceRegistrationForm;
@@ -34,10 +34,11 @@ use crate::servers::registar::ServiceRegistrationForm;
 ///
 /// It would panic if the `config::HttpTracker` struct would contain inappropriate values.
 ///
-#[instrument(skip(config, tracker, stats_event_sender, form))]
+#[instrument(skip(config, tracker, whitelist_authorization, stats_event_sender, form))]
 pub async fn start_job(
     config: &HttpTracker,
     tracker: Arc<core::Tracker>,
+    whitelist_authorization: Arc<whitelist::authorization::Authorization>,
     stats_event_sender: Arc<Option<Box<dyn Sender>>>,
     form: ServiceRegistrationForm,
     version: Version,
@@ -49,21 +50,32 @@ pub async fn start_job(
         .map(|tls| tls.expect("it should have a valid http tracker tls configuration"));
 
     match version {
-        Version::V1 => Some(start_v1(socket, tls, tracker.clone(), stats_event_sender.clone(), form).await),
+        Version::V1 => Some(
+            start_v1(
+                socket,
+                tls,
+                tracker.clone(),
+                whitelist_authorization.clone(),
+                stats_event_sender.clone(),
+                form,
+            )
+            .await,
+        ),
     }
 }
 
 #[allow(clippy::async_yields_async)]
-#[instrument(skip(socket, tls, tracker, stats_event_sender, form))]
+#[instrument(skip(socket, tls, tracker, whitelist_authorization, stats_event_sender, form))]
 async fn start_v1(
     socket: SocketAddr,
     tls: Option<RustlsConfig>,
     tracker: Arc<core::Tracker>,
+    whitelist_authorization: Arc<whitelist::authorization::Authorization>,
     stats_event_sender: Arc<Option<Box<dyn statistics::event::sender::Sender>>>,
     form: ServiceRegistrationForm,
 ) -> JoinHandle<()> {
     let server = HttpServer::new(Launcher::new(socket, tls))
-        .start(tracker, stats_event_sender, form)
+        .start(tracker, whitelist_authorization, stats_event_sender, form)
         .await
         .expect("it should be able to start to the http tracker");
 
@@ -88,7 +100,9 @@ mod tests {
 
     use crate::bootstrap::app::initialize_global_services;
     use crate::bootstrap::jobs::http_tracker::start_job;
-    use crate::core::services::{initialize_database, initialize_tracker, initialize_whitelist, statistics};
+    use crate::core::services::{initialize_database, initialize_tracker, statistics};
+    use crate::core::whitelist;
+    use crate::core::whitelist::repository::in_memory::InMemoryWhitelist;
     use crate::servers::http::Version;
     use crate::servers::registar::Registar;
 
@@ -104,13 +118,24 @@ mod tests {
         initialize_global_services(&cfg);
 
         let database = initialize_database(&cfg);
-        let whitelist_manager = initialize_whitelist(database.clone());
-        let tracker = Arc::new(initialize_tracker(&cfg, &database, &whitelist_manager));
+        let in_memory_whitelist = Arc::new(InMemoryWhitelist::default());
+        let whitelist_authorization = Arc::new(whitelist::authorization::Authorization::new(
+            &cfg.core,
+            &in_memory_whitelist.clone(),
+        ));
+        let tracker = Arc::new(initialize_tracker(&cfg, &database, &whitelist_authorization));
 
         let version = Version::V1;
 
-        start_job(config, tracker, stats_event_sender, Registar::default().give_form(), version)
-            .await
-            .expect("it should be able to join to the http tracker start-job");
+        start_job(
+            config,
+            tracker,
+            whitelist_authorization,
+            stats_event_sender,
+            Registar::default().give_form(),
+            version,
+        )
+        .await
+        .expect("it should be able to join to the http tracker start-job");
     }
 }

src/bootstrap/jobs/tracker_apis.rs

@@ -30,9 +30,10 @@ use torrust_tracker_configuration::{AccessTokens, HttpApi};
 use tracing::instrument;
 
 use super::make_rust_tls;
-use crate::core;
 use crate::core::statistics::event::sender::Sender;
 use crate::core::statistics::repository::Repository;
+use crate::core::whitelist::manager::WhiteListManager;
+use crate::core::{self};
 use crate::servers::apis::server::{ApiServer, Launcher};
 use crate::servers::apis::Version;
 use crate::servers::registar::ServiceRegistrationForm;
@@ -58,10 +59,12 @@ pub struct ApiServerJobStarted();
 /// It would panic if unable to send the  `ApiServerJobStarted` notice.
 ///
 ///
-#[instrument(skip(config, tracker, ban_service, stats_event_sender, stats_repository, form))]
+#[allow(clippy::too_many_arguments)]
+#[instrument(skip(config, tracker, whitelist_manager, ban_service, stats_event_sender, stats_repository, form))]
 pub async fn start_job(
     config: &HttpApi,
     tracker: Arc<core::Tracker>,
+    whitelist_manager: Arc<WhiteListManager>,
     ban_service: Arc<RwLock<BanService>>,
     stats_event_sender: Arc<Option<Box<dyn Sender>>>,
     stats_repository: Arc<Repository>,
@@ -82,6 +85,7 @@ pub async fn start_job(
                 bind_to,
                 tls,
                 tracker.clone(),
+                whitelist_manager.clone(),
                 ban_service.clone(),
                 stats_event_sender.clone(),
                 stats_repository.clone(),
@@ -99,6 +103,7 @@ pub async fn start_job(
     socket,
     tls,
     tracker,
+    whitelist_manager,
     ban_service,
     stats_event_sender,
     stats_repository,
@@ -109,6 +114,7 @@ async fn start_v1(
     socket: SocketAddr,
     tls: Option<RustlsConfig>,
     tracker: Arc<core::Tracker>,
+    whitelist_manager: Arc<WhiteListManager>,
     ban_service: Arc<RwLock<BanService>>,
     stats_event_sender: Arc<Option<Box<dyn Sender>>>,
     stats_repository: Arc<Repository>,
@@ -118,6 +124,7 @@ async fn start_v1(
     let server = ApiServer::new(Launcher::new(socket, tls))
         .start(
             tracker,
+            whitelist_manager,
             stats_event_sender,
             stats_repository,
             ban_service,
@@ -142,7 +149,9 @@ mod tests {
 
     use crate::bootstrap::app::initialize_global_services;
     use crate::bootstrap::jobs::tracker_apis::start_job;
-    use crate::core::services::{initialize_database, initialize_tracker, initialize_whitelist, statistics};
+    use crate::core::services::{initialize_database, initialize_tracker, initialize_whitelist_manager, statistics};
+    use crate::core::whitelist;
+    use crate::core::whitelist::repository::in_memory::InMemoryWhitelist;
     use crate::servers::apis::Version;
     use crate::servers::registar::Registar;
     use crate::servers::udp::server::banning::BanService;
@@ -161,14 +170,21 @@ mod tests {
         initialize_global_services(&cfg);
 
         let database = initialize_database(&cfg);
-        let whitelist_manager = initialize_whitelist(database.clone());
-        let tracker = Arc::new(initialize_tracker(&cfg, &database, &whitelist_manager));
+        let in_memory_whitelist = Arc::new(InMemoryWhitelist::default());
+        let whitelist_authorization = Arc::new(whitelist::authorization::Authorization::new(
+            &cfg.core,
+            &in_memory_whitelist.clone(),
+        ));
+        let whitelist_manager = initialize_whitelist_manager(database.clone(), in_memory_whitelist.clone());
+
+        let tracker = Arc::new(initialize_tracker(&cfg, &database, &whitelist_authorization));
 
         let version = Version::V1;
 
         start_job(
             config,
             tracker,
+            whitelist_manager,
             ban_service,
             stats_event_sender,
             stats_repository,

src/bootstrap/jobs/udp_tracker.rs

@@ -13,8 +13,8 @@ use tokio::task::JoinHandle;
 use torrust_tracker_configuration::UdpTracker;
 use tracing::instrument;
 
-use crate::core;
 use crate::core::statistics::event::sender::Sender;
+use crate::core::{self, whitelist};
 use crate::servers::registar::ServiceRegistrationForm;
 use crate::servers::udp::server::banning::BanService;
 use crate::servers::udp::server::spawner::Spawner;
@@ -32,10 +32,11 @@ use crate::servers::udp::UDP_TRACKER_LOG_TARGET;
 /// It will panic if the task did not finish successfully.
 #[must_use]
 #[allow(clippy::async_yields_async)]
-#[instrument(skip(config, tracker, stats_event_sender, ban_service, form))]
+#[instrument(skip(config, tracker, whitelist_authorization, stats_event_sender, ban_service, form))]
 pub async fn start_job(
     config: &UdpTracker,
     tracker: Arc<core::Tracker>,
+    whitelist_authorization: Arc<whitelist::authorization::Authorization>,
     stats_event_sender: Arc<Option<Box<dyn Sender>>>,
     ban_service: Arc<RwLock<BanService>>,
     form: ServiceRegistrationForm,
@@ -44,7 +45,14 @@ pub async fn start_job(
     let cookie_lifetime = config.cookie_lifetime;
 
     let server = Server::new(Spawner::new(bind_to))
-        .start(tracker, stats_event_sender, ban_service, form, cookie_lifetime)
+        .start(
+            tracker,
+            whitelist_authorization,
+            stats_event_sender,
+            ban_service,
+            form,
+            cookie_lifetime,
+        )
         .await
         .expect("it should be able to start the udp tracker");
 

src/container.rs

@@ -4,12 +4,13 @@ use tokio::sync::RwLock;
 
 use crate::core::statistics::event::sender::Sender;
 use crate::core::statistics::repository::Repository;
-use crate::core::whitelist::WhiteListManager;
-use crate::core::Tracker;
+use crate::core::whitelist::manager::WhiteListManager;
+use crate::core::{whitelist, Tracker};
 use crate::servers::udp::server::banning::BanService;
 
 pub struct AppContainer {
     pub tracker: Arc<Tracker>,
+    pub whitelist_authorization: Arc<whitelist::authorization::Authorization>,
     pub ban_service: Arc<RwLock<BanService>>,
     pub stats_event_sender: Arc<Option<Box<dyn Sender>>>,
     pub stats_repository: Arc<Repository>,