refactor: [torrust#1298] remove duplicate code

Author: josecelano

tests/servers/udp/contract.rs

@@ -229,7 +229,7 @@ mod receiving_an_announce_request {
         logging::setup();
 
         let env = Started::new(&configuration::ephemeral().into()).await;
-        let ban_service = env.udp_tracker_container.ban_service.clone();
+        let ban_service = env.container.udp_tracker_core_container.ban_service.clone();
 
         let client = match UdpTrackerClient::new(env.bind_address(), DEFAULT_TIMEOUT).await {
             Ok(udp_tracker_client) => udp_tracker_client,
@@ -270,7 +270,13 @@ mod receiving_an_announce_request {
             info_hash,
         );
 
-        let udp_requests_banned_before = env.udp_stats_repository.get_stats().await.udp_requests_banned;
+        let udp_requests_banned_before = env
+            .container
+            .udp_tracker_core_container
+            .udp_stats_repository
+            .get_stats()
+            .await
+            .udp_requests_banned;
 
         // This should return a timeout error
         match client.send(announce_request.into()).await {
@@ -280,7 +286,13 @@ mod receiving_an_announce_request {
 
         assert!(client.receive().await.is_err());
 
-        let udp_requests_banned_after = env.udp_stats_repository.get_stats().await.udp_requests_banned;
+        let udp_requests_banned_after = env
+            .container
+            .udp_tracker_core_container
+            .udp_stats_repository
+            .get_stats()
+            .await
+            .udp_requests_banned;
         let udp_banned_ips_total_after = ban_service.read().await.get_banned_ips_total();
 
         // UDP counter for banned requests should be increased by 1

tests/servers/udp/environment.rs

@@ -2,20 +2,10 @@ use std::net::SocketAddr;
 use std::sync::Arc;
 
 use bittorrent_primitives::info_hash::InfoHash;
-use bittorrent_tracker_core::announce_handler::AnnounceHandler;
-use bittorrent_tracker_core::databases::setup::initialize_database;
-use bittorrent_tracker_core::databases::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::authorization::WhitelistAuthorization;
-use bittorrent_tracker_core::whitelist::repository::in_memory::InMemoryWhitelist;
+use bittorrent_tracker_core::container::TrackerCoreContainer;
 use bittorrent_udp_tracker_core::container::UdpTrackerCoreContainer;
-use bittorrent_udp_tracker_core::services::banning::BanService;
-use bittorrent_udp_tracker_core::{statistics, MAX_CONNECTION_ID_ERRORS_PER_IP};
-use tokio::sync::RwLock;
 use torrust_server_lib::registar::Registar;
-use torrust_tracker_configuration::{Configuration, Core, UdpTracker, DEFAULT_TIMEOUT};
+use torrust_tracker_configuration::{Configuration, DEFAULT_TIMEOUT};
 use torrust_tracker_lib::bootstrap::app::initialize_global_services;
 use torrust_tracker_lib::servers::udp::server::spawner::Spawner;
 use torrust_tracker_lib::servers::udp::server::states::{Running, Stopped};
@@ -26,12 +16,7 @@ pub struct Environment<S>
 where
     S: std::fmt::Debug + std::fmt::Display,
 {
-    pub udp_tracker_container: Arc<UdpTrackerCoreContainer>,
-
-    pub database: Arc<Box<dyn Database>>,
-    pub in_memory_torrent_repository: Arc<InMemoryTorrentRepository>,
-    pub udp_stats_repository: Arc<statistics::repository::Repository>,
-
+    pub container: Arc<EnvContainer>,
     pub registar: Registar,
     pub server: Server<S>,
 }
@@ -43,7 +28,11 @@ where
     /// Add a torrent to the tracker
     #[allow(dead_code)]
     pub fn add_torrent(&self, info_hash: &InfoHash, peer: &peer::Peer) {
-        let () = self.in_memory_torrent_repository.upsert_peer(info_hash, peer);
+        let () = self
+            .container
+            .tracker_core_container
+            .in_memory_torrent_repository
+            .upsert_peer(info_hash, peer);
     }
 }
 
@@ -52,51 +41,33 @@ impl Environment<Stopped> {
     pub fn new(configuration: &Arc<Configuration>) -> Self {
         initialize_global_services(configuration);
 
-        let env_container = EnvContainer::initialize(configuration);
+        let container = Arc::new(EnvContainer::initialize(configuration));
 
-        let bind_to = env_container.udp_tracker_config.bind_address;
+        let bind_to = container.udp_tracker_core_container.udp_tracker_config.bind_address;
 
         let server = Server::new(Spawner::new(bind_to));
 
-        let udp_tracker_container = Arc::new(UdpTrackerCoreContainer {
-            core_config: env_container.core_config.clone(),
-            announce_handler: env_container.udp_tracker_core_container.announce_handler.clone(),
-            scrape_handler: env_container.udp_tracker_core_container.scrape_handler.clone(),
-            whitelist_authorization: env_container.udp_tracker_core_container.whitelist_authorization.clone(),
-
-            udp_tracker_config: env_container.udp_tracker_config.clone(),
-            udp_stats_event_sender: env_container.udp_tracker_core_container.udp_stats_event_sender.clone(),
-            udp_stats_repository: env_container.udp_tracker_core_container.udp_stats_repository.clone(),
-            ban_service: env_container.udp_tracker_core_container.ban_service.clone(),
-        });
-
         Self {
-            udp_tracker_container,
-
-            database: env_container.database.clone(),
-            in_memory_torrent_repository: env_container.in_memory_torrent_repository.clone(),
-            udp_stats_repository: env_container.udp_stats_repository.clone(),
-
+            container,
             registar: Registar::default(),
             server,
         }
     }
 
     #[allow(dead_code)]
     pub async fn start(self) -> Environment<Running> {
-        let cookie_lifetime = self.udp_tracker_container.udp_tracker_config.cookie_lifetime;
+        let cookie_lifetime = self.container.udp_tracker_core_container.udp_tracker_config.cookie_lifetime;
 
         Environment {
-            udp_tracker_container: self.udp_tracker_container.clone(),
-
-            database: self.database.clone(),
-            in_memory_torrent_repository: self.in_memory_torrent_repository.clone(),
-            udp_stats_repository: self.udp_stats_repository.clone(),
-
+            container: self.container.clone(),
             registar: self.registar.clone(),
             server: self
                 .server
-                .start(self.udp_tracker_container, self.registar.give_form(), cookie_lifetime)
+                .start(
+                    self.container.udp_tracker_core_container.clone(),
+                    self.registar.give_form(),
+                    cookie_lifetime,
+                )
                 .await
                 .unwrap(),
         }
@@ -117,12 +88,7 @@ impl Environment<Running> {
             .expect("it should stop the environment within the timeout");
 
         Environment {
-            udp_tracker_container: self.udp_tracker_container,
-
-            database: self.database,
-            in_memory_torrent_repository: self.in_memory_torrent_repository,
-            udp_stats_repository: self.udp_stats_repository,
-
+            container: self.container,
             registar: Registar::default(),
             server: stopped.expect("it stop the udp tracker service"),
         }
@@ -134,13 +100,8 @@ impl Environment<Running> {
 }
 
 pub struct EnvContainer {
-    pub core_config: Arc<Core>,
-    pub udp_tracker_config: Arc<UdpTracker>,
+    pub tracker_core_container: Arc<TrackerCoreContainer>,
     pub udp_tracker_core_container: Arc<UdpTrackerCoreContainer>,
-
-    pub database: Arc<Box<dyn Database>>,
-    pub in_memory_torrent_repository: Arc<InMemoryTorrentRepository>,
-    pub udp_stats_repository: Arc<bittorrent_udp_tracker_core::statistics::repository::Repository>,
 }
 
 impl EnvContainer {
@@ -149,48 +110,12 @@ impl EnvContainer {
         let udp_tracker_configurations = configuration.udp_trackers.clone().expect("missing UDP tracker configuration");
         let udp_tracker_config = Arc::new(udp_tracker_configurations[0].clone());
 
-        // UDP stats
-        let (udp_stats_event_sender, udp_stats_repository) =
-            bittorrent_udp_tracker_core::statistics::setup::factory(configuration.core.tracker_usage_statistics);
-        let udp_stats_event_sender = Arc::new(udp_stats_event_sender);
-        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(&configuration.core);
-        let in_memory_whitelist = Arc::new(InMemoryWhitelist::default());
-        let whitelist_authorization = Arc::new(WhitelistAuthorization::new(&configuration.core, &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(
-            &configuration.core,
-            &whitelist_authorization,
-            &in_memory_torrent_repository,
-            &db_torrent_repository,
-        ));
-
-        let scrape_handler = Arc::new(ScrapeHandler::new(&whitelist_authorization, &in_memory_torrent_repository));
-
-        let udp_tracker_container = Arc::new(UdpTrackerCoreContainer {
-            core_config: core_config.clone(),
-            announce_handler: announce_handler.clone(),
-            scrape_handler: scrape_handler.clone(),
-            whitelist_authorization: whitelist_authorization.clone(),
-
-            udp_tracker_config: udp_tracker_config.clone(),
-            udp_stats_event_sender: udp_stats_event_sender.clone(),
-            udp_stats_repository: udp_stats_repository.clone(),
-            ban_service: ban_service.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);
 
         Self {
-            core_config,
-            udp_tracker_config,
-            udp_tracker_core_container: udp_tracker_container,
-
-            database,
-            in_memory_torrent_repository,
-            udp_stats_repository,
+            tracker_core_container,
+            udp_tracker_core_container,
         }
     }
 }