Merge #1310: Refactor packages: changes needed to extract new packages

56ae9f3 refactor: [#1298] rename method (Jose Celano)
4b250c3 refactor: [#1298] convert fn into static method (Jose Celano)
0a44d01 refactor: [#1298] remove duplicate code (Jose Celano)
3ce6fb2 refactor: [#1298] reorganize code (Jose Celano)
3052ebe refactor: [#1298] convert fn into static method (Jose Celano)
c8ec781 refactor: [#1298] move HttpApiContainer to tracker-api-core package (Jose Celano)
be05211 refactor: [#1298] remove duplicate code (Jose Celano)
292a7eb refactor: [#1298] convert fn into static method (Jose Celano)
5c1fd97 refactor: [#1298] rename struct to UdpTrackerCoreContainer (Jose Celano)
de75a32 refactor: [#1298] move UdpTrackerContainer to udp-tracker-core package (Jose Celano)
786000b refactor: [#1298] remove duplicate code (Jose Celano)
1eca6a3 refactor: [#1298] rename struct and field (Jose Celano)
b562f8d refacotr: [#1298] remove duplicate code (Jose Celano)
06a29cd refactor: [#1298] convert fn into static method (Jose Celano)
d152043 refactor: [#1298] mmove HttpTrackerContainer to http-tracker-core (Jose Celano)
9f18c6e refactor: [#1298] extract TrackerCoreContainer (Jose Celano)
bdec261 refactor: [#1298] move functions to container mod (Jose Celano)
9ba5cdd refactor: [#1298] inine function (Jose Celano)
78002d7 refactor: [#1298] remove dependency on global app container in packages (Jose Celano)
1bd5f0a refactor: [#1298] move loggin setup to configration package (Jose Celano)
265da2d refactor: [#1298] inject only logging config in logging setup (Jose Celano)

Pull request description:

  Refactor packages: changes needed to extract new packages.

ACKs for top commit:
  josecelano:
    ACK 56ae9f3

Tree-SHA512: 6d7d2660fe90570e45ab901bb1ac5ab0cd9f3430eecd538ef7c9cca024b51474aed1f300b65ad9c389acf88573cdc88eb66884716d6add2e39910e43b6f7d48f

Author: josecelano

Cargo.lock

@@ -305,7 +305,6 @@
 //! - [Bencode to Json Online converter](https://chocobo1.github.io/bencode_online).
 use serde::{Deserialize, Serialize};
 
-pub mod container;
 pub mod server;
 pub mod v1;
 

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

@@ -4,6 +4,7 @@ use std::sync::Arc;
 
 use axum_server::tls_rustls::RustlsConfig;
 use axum_server::Handle;
+use bittorrent_http_tracker_core::container::HttpTrackerCoreContainer;
 use derive_more::Constructor;
 use futures::future::BoxFuture;
 use tokio::sync::oneshot::{Receiver, Sender};
@@ -15,7 +16,6 @@ use torrust_server_lib::signals::{Halted, Started};
 use tracing::instrument;
 
 use super::v1::routes::router;
-use crate::container::HttpTrackerContainer;
 use crate::HTTP_TRACKER_LOG_TARGET;
 
 /// Error that can occur when starting or stopping the HTTP server.
@@ -45,7 +45,7 @@ impl Launcher {
     #[instrument(skip(self, http_tracker_container, tx_start, rx_halt))]
     fn start(
         &self,
-        http_tracker_container: Arc<HttpTrackerContainer>,
+        http_tracker_container: Arc<HttpTrackerCoreContainer>,
         tx_start: Sender<Started>,
         rx_halt: Receiver<Halted>,
     ) -> BoxFuture<'static, ()> {
@@ -160,7 +160,7 @@ impl HttpServer<Stopped> {
     /// back to the main thread.
     pub async fn start(
         self,
-        http_tracker_container: Arc<HttpTrackerContainer>,
+        http_tracker_container: Arc<HttpTrackerCoreContainer>,
         form: ServiceRegistrationForm,
     ) -> Result<HttpServer<Running>, Error> {
         let (tx_start, rx_start) = tokio::sync::oneshot::channel::<Started>();
@@ -238,6 +238,7 @@ pub fn check_fn(binding: &SocketAddr) -> ServiceHealthCheckJob {
 mod tests {
     use std::sync::Arc;
 
+    use bittorrent_http_tracker_core::container::HttpTrackerCoreContainer;
     use bittorrent_tracker_core::announce_handler::AnnounceHandler;
     use bittorrent_tracker_core::authentication::key::repository::in_memory::InMemoryKeyRepository;
     use bittorrent_tracker_core::authentication::service;
@@ -252,10 +253,9 @@ mod tests {
     use torrust_tracker_configuration::Configuration;
     use torrust_tracker_test_helpers::configuration::ephemeral_public;
 
-    use crate::container::HttpTrackerContainer;
     use crate::server::{HttpServer, Launcher};
 
-    pub fn initialize_container(configuration: &Configuration) -> HttpTrackerContainer {
+    pub fn initialize_container(configuration: &Configuration) -> HttpTrackerCoreContainer {
         let core_config = Arc::new(configuration.core.clone());
 
         let http_trackers = configuration
@@ -268,9 +268,10 @@ mod tests {
         let http_tracker_config = Arc::new(http_tracker_config.clone());
 
         // HTTP stats
-        let (http_stats_event_sender, _http_stats_repository) =
+        let (http_stats_event_sender, http_stats_repository) =
             bittorrent_http_tracker_core::statistics::setup::factory(configuration.core.tracker_usage_statistics);
         let http_stats_event_sender = Arc::new(http_stats_event_sender);
+        let http_stats_repository = Arc::new(http_stats_repository);
 
         let database = initialize_database(&configuration.core);
         let in_memory_whitelist = Arc::new(InMemoryWhitelist::default());
@@ -292,14 +293,16 @@ mod tests {
 
         let scrape_handler = Arc::new(ScrapeHandler::new(&whitelist_authorization, &in_memory_torrent_repository));
 
-        HttpTrackerContainer {
+        HttpTrackerCoreContainer {
             core_config,
-            http_tracker_config,
             announce_handler,
             scrape_handler,
             whitelist_authorization,
-            http_stats_event_sender,
             authentication_service,
+
+            http_tracker_config,
+            http_stats_event_sender,
+            http_stats_repository,
         }
     }
 

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

@@ -9,6 +9,7 @@ use axum::response::Response;
 use axum::routing::get;
 use axum::{BoxError, Router};
 use axum_client_ip::SecureClientIpSource;
+use bittorrent_http_tracker_core::container::HttpTrackerCoreContainer;
 use hyper::{Request, StatusCode};
 use torrust_server_lib::logging::Latency;
 use torrust_tracker_configuration::DEFAULT_TIMEOUT;
@@ -23,15 +24,14 @@ use tower_http::LatencyUnit;
 use tracing::{instrument, Level, Span};
 
 use super::handlers::{announce, health_check, scrape};
-use crate::container::HttpTrackerContainer;
 use crate::HTTP_TRACKER_LOG_TARGET;
 
 /// It adds the routes to the router.
 ///
 /// > **NOTICE**: it's added a layer to get the client IP from the connection
 /// > info. The tracker could use the connection info to get the client IP.
 #[instrument(skip(http_tracker_container, server_socket_addr))]
-pub fn router(http_tracker_container: Arc<HttpTrackerContainer>, server_socket_addr: SocketAddr) -> Router {
+pub fn router(http_tracker_container: Arc<HttpTrackerCoreContainer>, server_socket_addr: SocketAddr) -> Router {
     Router::new()
         // Health check
         .route("/health_check", get(health_check::handler))

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

@@ -24,6 +24,8 @@ serde_with = "3"
 thiserror = "2"
 toml = "0"
 torrust-tracker-located-error = { version = "3.0.0-develop", path = "../located-error" }
+tracing = "0"
+tracing-subscriber = { version = "0", features = ["json"] }
 url = "2"
 
 [dev-dependencies]

packages/axum-http-tracker-server/src/v1/routes.rs

@@ -4,6 +4,7 @@
 //! Torrust Tracker, which is a `BitTorrent` tracker server.
 //!
 //! The current version for configuration is [`v2_0_0`].
+pub mod logging;
 pub mod v2_0_0;
 pub mod validator;
 
@@ -37,6 +38,7 @@ pub const ENV_VAR_CONFIG_TOML_PATH: &str = "TORRUST_TRACKER_CONFIG_TOML_PATH";
 
 pub type Configuration = v2_0_0::Configuration;
 pub type Core = v2_0_0::core::Core;
+pub type Logging = v2_0_0::logging::Logging;
 pub type HealthCheckApi = v2_0_0::health_check_api::HealthCheckApi;
 pub type HttpApi = v2_0_0::tracker_api::HttpApi;
 pub type HttpTracker = v2_0_0::http_tracker::HttpTracker;

packages/configuration/Cargo.toml

@@ -13,15 +13,16 @@
 //! Refer to the [configuration crate documentation](https://docs.rs/torrust-tracker-configuration) to know how to change log settings.
 use std::sync::Once;
 
-use torrust_tracker_configuration::{Configuration, Threshold};
 use tracing::level_filters::LevelFilter;
 
+use crate::{Logging, Threshold};
+
 static INIT: Once = Once::new();
 
 /// It redirects the log info to the standard output with the log threshold
 /// defined in the configuration.
-pub fn setup(cfg: &Configuration) {
-    let tracing_level = map_to_tracing_level_filter(&cfg.logging.threshold);
+pub fn setup(cfg: &Logging) {
+    let tracing_level = map_to_tracing_level_filter(&cfg.threshold);
 
     if tracing_level == LevelFilter::OFF {
         return;

packages/configuration/src/lib.rs

@@ -0,0 +1,54 @@
+use std::sync::Arc;
+
+use bittorrent_tracker_core::announce_handler::AnnounceHandler;
+use bittorrent_tracker_core::authentication::service::AuthenticationService;
+use bittorrent_tracker_core::container::TrackerCoreContainer;
+use bittorrent_tracker_core::scrape_handler::ScrapeHandler;
+use bittorrent_tracker_core::whitelist;
+use torrust_tracker_configuration::{Core, HttpTracker};
+
+use crate::statistics;
+
+pub struct HttpTrackerCoreContainer {
+    // todo: replace with TrackerCoreContainer
+    pub core_config: Arc<Core>,
+    pub announce_handler: Arc<AnnounceHandler>,
+    pub scrape_handler: Arc<ScrapeHandler>,
+    pub whitelist_authorization: Arc<whitelist::authorization::WhitelistAuthorization>,
+    pub authentication_service: Arc<AuthenticationService>,
+
+    pub http_tracker_config: Arc<HttpTracker>,
+    pub http_stats_event_sender: Arc<Option<Box<dyn statistics::event::sender::Sender>>>,
+    pub http_stats_repository: Arc<statistics::repository::Repository>,
+}
+
+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)
+    }
+
+    #[must_use]
+    pub fn initialize_from(
+        tracker_core_container: &Arc<TrackerCoreContainer>,
+        http_tracker_config: &Arc<HttpTracker>,
+    ) -> 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);
+
+        Arc::new(Self {
+            core_config: tracker_core_container.core_config.clone(),
+            announce_handler: tracker_core_container.announce_handler.clone(),
+            scrape_handler: tracker_core_container.scrape_handler.clone(),
+            whitelist_authorization: tracker_core_container.whitelist_authorization.clone(),
+            authentication_service: tracker_core_container.authentication_service.clone(),
+
+            http_tracker_config: http_tracker_config.clone(),
+            http_stats_event_sender: http_stats_event_sender.clone(),
+            http_stats_repository: http_stats_repository.clone(),
+        })
+    }
+}

src/bootstrap/logging.rs packages/configuration/src/logging.rs

@@ -1,3 +1,4 @@
+pub mod container;
 pub mod services;
 pub mod statistics;
 

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

@@ -0,0 +1,72 @@
+use std::sync::Arc;
+
+use bittorrent_http_tracker_core::container::HttpTrackerCoreContainer;
+use bittorrent_tracker_core::authentication::handler::KeysHandler;
+use bittorrent_tracker_core::container::TrackerCoreContainer;
+use bittorrent_tracker_core::torrent::repository::in_memory::InMemoryTorrentRepository;
+use bittorrent_tracker_core::whitelist::manager::WhitelistManager;
+use bittorrent_udp_tracker_core::container::UdpTrackerCoreContainer;
+use bittorrent_udp_tracker_core::services::banning::BanService;
+use bittorrent_udp_tracker_core::{self};
+use tokio::sync::RwLock;
+use torrust_tracker_configuration::{Core, HttpApi, HttpTracker, UdpTracker};
+
+pub struct TrackerHttpApiCoreContainer {
+    // todo: replace with TrackerCoreContainer
+    pub core_config: Arc<Core>,
+    pub in_memory_torrent_repository: Arc<InMemoryTorrentRepository>,
+    pub keys_handler: Arc<KeysHandler>,
+    pub whitelist_manager: Arc<WhitelistManager>,
+
+    // todo: replace with HttpTrackerCoreContainer
+    pub http_stats_repository: Arc<bittorrent_http_tracker_core::statistics::repository::Repository>,
+
+    // todo: replace with UdpTrackerCoreContainer
+    pub ban_service: Arc<RwLock<BanService>>,
+    pub udp_stats_repository: Arc<bittorrent_udp_tracker_core::statistics::repository::Repository>,
+
+    pub http_api_config: Arc<HttpApi>,
+}
+
+impl TrackerHttpApiCoreContainer {
+    #[must_use]
+    pub fn initialize(
+        core_config: &Arc<Core>,
+        http_tracker_config: &Arc<HttpTracker>,
+        udp_tracker_config: &Arc<UdpTracker>,
+        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);
+
+        Self::initialize_from(
+            &tracker_core_container,
+            &http_tracker_core_container,
+            &udp_tracker_core_container,
+            http_api_config,
+        )
+    }
+
+    #[must_use]
+    pub fn initialize_from(
+        tracker_core_container: &Arc<TrackerCoreContainer>,
+        http_tracker_core_container: &Arc<HttpTrackerCoreContainer>,
+        udp_tracker_core_container: &Arc<UdpTrackerCoreContainer>,
+        http_api_config: &Arc<HttpApi>,
+    ) -> Arc<TrackerHttpApiCoreContainer> {
+        Arc::new(TrackerHttpApiCoreContainer {
+            core_config: tracker_core_container.core_config.clone(),
+            in_memory_torrent_repository: tracker_core_container.in_memory_torrent_repository.clone(),
+            keys_handler: tracker_core_container.keys_handler.clone(),
+            whitelist_manager: tracker_core_container.whitelist_manager.clone(),
+
+            http_stats_repository: http_tracker_core_container.http_stats_repository.clone(),
+
+            ban_service: udp_tracker_core_container.ban_service.clone(),
+            udp_stats_repository: udp_tracker_core_container.udp_stats_repository.clone(),
+
+            http_api_config: http_api_config.clone(),
+        })
+    }
+}

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

@@ -1 +1,2 @@
+pub mod container;
 pub mod statistics;