refactor: [torrust#1326] extract bittorrent_http_tracker_core::services::announce::AnnounceService

Author: josecelano

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

@@ -239,6 +239,7 @@ mod tests {
     use std::sync::Arc;
 
     use bittorrent_http_tracker_core::container::HttpTrackerCoreContainer;
+    use bittorrent_http_tracker_core::services::announce::AnnounceService;
     use bittorrent_tracker_core::announce_handler::AnnounceHandler;
     use bittorrent_tracker_core::authentication::key::repository::in_memory::InMemoryKeyRepository;
     use bittorrent_tracker_core::authentication::service;
@@ -293,6 +294,14 @@ mod tests {
 
         let scrape_handler = Arc::new(ScrapeHandler::new(&whitelist_authorization, &in_memory_torrent_repository));
 
+        let announce_service = Arc::new(AnnounceService::new(
+            core_config.clone(),
+            announce_handler.clone(),
+            authentication_service.clone(),
+            whitelist_authorization.clone(),
+            http_stats_event_sender.clone(),
+        ));
+
         HttpTrackerCoreContainer {
             core_config,
             announce_handler,
@@ -303,6 +312,7 @@ mod tests {
             http_tracker_config,
             http_stats_event_sender,
             http_stats_repository,
+            announce_service,
         }
     }
 

packages/axum-http-tracker-server/src/v1/handlers/announce.rs

@@ -6,16 +6,12 @@ use std::sync::Arc;
 
 use axum::extract::State;
 use axum::response::{IntoResponse, Response};
-use bittorrent_http_tracker_core::services::announce::HttpAnnounceError;
+use bittorrent_http_tracker_core::services::announce::{AnnounceService, HttpAnnounceError};
 use bittorrent_http_tracker_protocol::v1::requests::announce::{Announce, Compact};
 use bittorrent_http_tracker_protocol::v1::responses::{self};
 use bittorrent_http_tracker_protocol::v1::services::peer_ip_resolver::ClientIpSources;
-use bittorrent_tracker_core::announce_handler::AnnounceHandler;
-use bittorrent_tracker_core::authentication::service::AuthenticationService;
 use bittorrent_tracker_core::authentication::Key;
-use bittorrent_tracker_core::whitelist;
 use hyper::StatusCode;
-use torrust_tracker_configuration::Core;
 use torrust_tracker_primitives::core::AnnounceData;
 
 use crate::v1::extractors::announce_request::ExtractRequest;
@@ -25,91 +21,41 @@ use crate::v1::extractors::client_ip_sources::Extract as ExtractClientIpSources;
 /// It handles the `announce` request when the HTTP tracker does not require
 /// authentication (no PATH `key` parameter required).
 #[allow(clippy::unused_async)]
-#[allow(clippy::type_complexity)]
 pub async fn handle_without_key(
-    State(state): State<(
-        Arc<Core>,
-        Arc<AnnounceHandler>,
-        Arc<AuthenticationService>,
-        Arc<whitelist::authorization::WhitelistAuthorization>,
-        Arc<Option<Box<dyn bittorrent_http_tracker_core::statistics::event::sender::Sender>>>,
-    )>,
+    State(state): State<Arc<AnnounceService>>,
     ExtractRequest(announce_request): ExtractRequest,
     ExtractClientIpSources(client_ip_sources): ExtractClientIpSources,
 ) -> Response {
     tracing::debug!("http announce request: {:#?}", announce_request);
 
-    handle(
-        &state.0,
-        &state.1,
-        &state.2,
-        &state.3,
-        &state.4,
-        &announce_request,
-        &client_ip_sources,
-        None,
-    )
-    .await
+    handle(&state, &announce_request, &client_ip_sources, None).await
 }
 
 /// It handles the `announce` request when the HTTP tracker requires
 /// authentication (PATH `key` parameter required).
 #[allow(clippy::unused_async)]
-#[allow(clippy::type_complexity)]
 pub async fn handle_with_key(
-    State(state): State<(
-        Arc<Core>,
-        Arc<AnnounceHandler>,
-        Arc<AuthenticationService>,
-        Arc<whitelist::authorization::WhitelistAuthorization>,
-        Arc<Option<Box<dyn bittorrent_http_tracker_core::statistics::event::sender::Sender>>>,
-    )>,
+    State(state): State<Arc<AnnounceService>>,
     ExtractRequest(announce_request): ExtractRequest,
     ExtractClientIpSources(client_ip_sources): ExtractClientIpSources,
     ExtractKey(key): ExtractKey,
 ) -> Response {
     tracing::debug!("http announce request: {:#?}", announce_request);
 
-    handle(
-        &state.0,
-        &state.1,
-        &state.2,
-        &state.3,
-        &state.4,
-        &announce_request,
-        &client_ip_sources,
-        Some(key),
-    )
-    .await
+    handle(&state, &announce_request, &client_ip_sources, Some(key)).await
 }
 
 /// It handles the `announce` request.
 ///
 /// Internal implementation that handles both the `authenticated` and
 /// `unauthenticated` modes.
-#[allow(clippy::too_many_arguments)]
 async fn handle(
-    config: &Arc<Core>,
-    announce_handler: &Arc<AnnounceHandler>,
-    authentication_service: &Arc<AuthenticationService>,
-    whitelist_authorization: &Arc<whitelist::authorization::WhitelistAuthorization>,
-    opt_http_stats_event_sender: &Arc<Option<Box<dyn bittorrent_http_tracker_core::statistics::event::sender::Sender>>>,
+    announce_service: &Arc<AnnounceService>,
     announce_request: &Announce,
     client_ip_sources: &ClientIpSources,
     maybe_key: Option<Key>,
 ) -> Response {
-    let announce_data = match handle_announce(
-        config,
-        announce_handler,
-        authentication_service,
-        whitelist_authorization,
-        opt_http_stats_event_sender,
-        announce_request,
-        client_ip_sources,
-        maybe_key,
-    )
-    .await
-    {
+    let announce_data = match handle_announce(announce_service, announce_request, client_ip_sources, maybe_key).await {
         Ok(announce_data) => announce_data,
         Err(error) => {
             let error_response = responses::error::Error {
@@ -121,28 +67,15 @@ async fn handle(
     build_response(announce_request, announce_data)
 }
 
-#[allow(clippy::too_many_arguments)]
 async fn handle_announce(
-    core_config: &Arc<Core>,
-    announce_handler: &Arc<AnnounceHandler>,
-    authentication_service: &Arc<AuthenticationService>,
-    whitelist_authorization: &Arc<whitelist::authorization::WhitelistAuthorization>,
-    opt_http_stats_event_sender: &Arc<Option<Box<dyn bittorrent_http_tracker_core::statistics::event::sender::Sender>>>,
+    announce_service: &Arc<AnnounceService>,
     announce_request: &Announce,
     client_ip_sources: &ClientIpSources,
     maybe_key: Option<Key>,
 ) -> Result<AnnounceData, HttpAnnounceError> {
-    bittorrent_http_tracker_core::services::announce::handle_announce(
-        &core_config.clone(),
-        &announce_handler.clone(),
-        &authentication_service.clone(),
-        &whitelist_authorization.clone(),
-        &opt_http_stats_event_sender.clone(),
-        announce_request,
-        client_ip_sources,
-        maybe_key,
-    )
-    .await
+    announce_service
+        .handle_announce(announce_request, client_ip_sources, maybe_key)
+        .await
 }
 
 fn build_response(announce_request: &Announce, announce_data: AnnounceData) -> Response {
@@ -163,6 +96,7 @@ mod tests {
     use std::sync::Arc;
 
     use aquatic_udp_protocol::PeerId;
+    use bittorrent_http_tracker_core::services::announce::AnnounceService;
     use bittorrent_http_tracker_protocol::v1::requests::announce::Announce;
     use bittorrent_http_tracker_protocol::v1::responses;
     use bittorrent_http_tracker_protocol::v1::services::peer_ip_resolver::ClientIpSources;
@@ -174,39 +108,32 @@ mod tests {
     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 torrust_tracker_configuration::{Configuration, Core};
+    use torrust_tracker_configuration::Configuration;
     use torrust_tracker_test_helpers::configuration;
 
     use crate::tests::helpers::sample_info_hash;
 
-    struct CoreTrackerServices {
-        pub core_config: Arc<Core>,
-        pub announce_handler: Arc<AnnounceHandler>,
-        pub whitelist_authorization: Arc<WhitelistAuthorization>,
-        pub authentication_service: Arc<AuthenticationService>,
-    }
-
     struct CoreHttpTrackerServices {
-        pub http_stats_event_sender: Arc<Option<Box<dyn bittorrent_http_tracker_core::statistics::event::sender::Sender>>>,
+        pub announce_service: Arc<AnnounceService>,
     }
 
-    fn initialize_private_tracker() -> (CoreTrackerServices, CoreHttpTrackerServices) {
+    fn initialize_private_tracker() -> CoreHttpTrackerServices {
         initialize_core_tracker_services(&configuration::ephemeral_private())
     }
 
-    fn initialize_listed_tracker() -> (CoreTrackerServices, CoreHttpTrackerServices) {
+    fn initialize_listed_tracker() -> CoreHttpTrackerServices {
         initialize_core_tracker_services(&configuration::ephemeral_listed())
     }
 
-    fn initialize_tracker_on_reverse_proxy() -> (CoreTrackerServices, CoreHttpTrackerServices) {
+    fn initialize_tracker_on_reverse_proxy() -> CoreHttpTrackerServices {
         initialize_core_tracker_services(&configuration::ephemeral_with_reverse_proxy())
     }
 
-    fn initialize_tracker_not_on_reverse_proxy() -> (CoreTrackerServices, CoreHttpTrackerServices) {
+    fn initialize_tracker_not_on_reverse_proxy() -> CoreHttpTrackerServices {
         initialize_core_tracker_services(&configuration::ephemeral_without_reverse_proxy())
     }
 
-    fn initialize_core_tracker_services(config: &Configuration) -> (CoreTrackerServices, CoreHttpTrackerServices) {
+    fn initialize_core_tracker_services(config: &Configuration) -> CoreHttpTrackerServices {
         let core_config = Arc::new(config.core.clone());
         let database = initialize_database(&config.core);
         let in_memory_whitelist = Arc::new(InMemoryWhitelist::default());
@@ -228,15 +155,15 @@ mod tests {
         let http_stats_event_sender = Arc::new(http_stats_event_sender);
         let _http_stats_repository = Arc::new(http_stats_repository);
 
-        (
-            CoreTrackerServices {
-                core_config,
-                announce_handler,
-                whitelist_authorization,
-                authentication_service,
-            },
-            CoreHttpTrackerServices { http_stats_event_sender },
-        )
+        let announce_service = Arc::new(AnnounceService::new(
+            core_config.clone(),
+            announce_handler.clone(),
+            authentication_service.clone(),
+            whitelist_authorization.clone(),
+            http_stats_event_sender.clone(),
+        ));
+
+        CoreHttpTrackerServices { announce_service }
     }
 
     fn sample_announce_request() -> Announce {
@@ -280,16 +207,12 @@ mod tests {
 
         #[tokio::test]
         async fn it_should_fail_when_the_authentication_key_is_missing() {
-            let (core_tracker_services, http_core_tracker_services) = initialize_private_tracker();
+            let http_core_tracker_services = initialize_private_tracker();
 
             let maybe_key = None;
 
             let response = handle_announce(
-                &core_tracker_services.core_config,
-                &core_tracker_services.announce_handler,
-                &core_tracker_services.authentication_service,
-                &core_tracker_services.whitelist_authorization,
-                &http_core_tracker_services.http_stats_event_sender,
+                &http_core_tracker_services.announce_service,
                 &sample_announce_request(),
                 &sample_client_ip_sources(),
                 maybe_key,
@@ -309,18 +232,14 @@ mod tests {
 
         #[tokio::test]
         async fn it_should_fail_when_the_authentication_key_is_invalid() {
-            let (core_tracker_services, http_core_tracker_services) = initialize_private_tracker();
+            let http_core_tracker_services = initialize_private_tracker();
 
             let unregistered_key = authentication::Key::from_str("YZSl4lMZupRuOpSRC3krIKR5BPB14nrJ").unwrap();
 
             let maybe_key = Some(unregistered_key);
 
             let response = handle_announce(
-                &core_tracker_services.core_config,
-                &core_tracker_services.announce_handler,
-                &core_tracker_services.authentication_service,
-                &core_tracker_services.whitelist_authorization,
-                &http_core_tracker_services.http_stats_event_sender,
+                &http_core_tracker_services.announce_service,
                 &sample_announce_request(),
                 &sample_client_ip_sources(),
                 maybe_key,
@@ -349,16 +268,12 @@ mod tests {
 
         #[tokio::test]
         async fn it_should_fail_when_the_announced_torrent_is_not_whitelisted() {
-            let (core_tracker_services, http_core_tracker_services) = initialize_listed_tracker();
+            let http_core_tracker_services = initialize_listed_tracker();
 
             let announce_request = sample_announce_request();
 
             let response = handle_announce(
-                &core_tracker_services.core_config,
-                &core_tracker_services.announce_handler,
-                &core_tracker_services.authentication_service,
-                &core_tracker_services.whitelist_authorization,
-                &http_core_tracker_services.http_stats_event_sender,
+                &http_core_tracker_services.announce_service,
                 &announce_request,
                 &sample_client_ip_sources(),
                 None,
@@ -391,19 +306,15 @@ mod tests {
 
         #[tokio::test]
         async fn it_should_fail_when_the_right_most_x_forwarded_for_header_ip_is_not_available() {
-            let (core_tracker_services, http_core_tracker_services) = initialize_tracker_on_reverse_proxy();
+            let http_core_tracker_services = initialize_tracker_on_reverse_proxy();
 
             let client_ip_sources = ClientIpSources {
                 right_most_x_forwarded_for: None,
                 connection_info_ip: None,
             };
 
             let response = handle_announce(
-                &core_tracker_services.core_config,
-                &core_tracker_services.announce_handler,
-                &core_tracker_services.authentication_service,
-                &core_tracker_services.whitelist_authorization,
-                &http_core_tracker_services.http_stats_event_sender,
+                &http_core_tracker_services.announce_service,
                 &sample_announce_request(),
                 &client_ip_sources,
                 None,
@@ -433,19 +344,15 @@ mod tests {
 
         #[tokio::test]
         async fn it_should_fail_when_the_client_ip_from_the_connection_info_is_not_available() {
-            let (core_tracker_services, http_core_tracker_services) = initialize_tracker_not_on_reverse_proxy();
+            let http_core_tracker_services = initialize_tracker_not_on_reverse_proxy();
 
             let client_ip_sources = ClientIpSources {
                 right_most_x_forwarded_for: None,
                 connection_info_ip: None,
             };
 
             let response = handle_announce(
-                &core_tracker_services.core_config,
-                &core_tracker_services.announce_handler,
-                &core_tracker_services.authentication_service,
-                &core_tracker_services.whitelist_authorization,
-                &http_core_tracker_services.http_stats_event_sender,
+                &http_core_tracker_services.announce_service,
                 &sample_announce_request(),
                 &client_ip_sources,
                 None,

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

@@ -38,23 +38,11 @@ pub fn router(http_tracker_container: Arc<HttpTrackerCoreContainer>, server_sock
         // Announce request
         .route(
             "/announce",
-            get(announce::handle_without_key).with_state((
-                http_tracker_container.core_config.clone(),
-                http_tracker_container.announce_handler.clone(),
-                http_tracker_container.authentication_service.clone(),
-                http_tracker_container.whitelist_authorization.clone(),
-                http_tracker_container.http_stats_event_sender.clone(),
-            )),
+            get(announce::handle_without_key).with_state(http_tracker_container.announce_service.clone()),
         )
         .route(
             "/announce/{key}",
-            get(announce::handle_with_key).with_state((
-                http_tracker_container.core_config.clone(),
-                http_tracker_container.announce_handler.clone(),
-                http_tracker_container.authentication_service.clone(),
-                http_tracker_container.whitelist_authorization.clone(),
-                http_tracker_container.http_stats_event_sender.clone(),
-            )),
+            get(announce::handle_with_key).with_state(http_tracker_container.announce_service.clone()),
         )
         // Scrape request
         .route(

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

@@ -7,6 +7,7 @@ use bittorrent_tracker_core::scrape_handler::ScrapeHandler;
 use bittorrent_tracker_core::whitelist;
 use torrust_tracker_configuration::{Core, HttpTracker};
 
+use crate::services::announce::AnnounceService;
 use crate::statistics;
 
 pub struct HttpTrackerCoreContainer {
@@ -20,6 +21,7 @@ pub struct HttpTrackerCoreContainer {
     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>,
+    pub announce_service: Arc<AnnounceService>,
 }
 
 impl HttpTrackerCoreContainer {
@@ -39,6 +41,14 @@ impl HttpTrackerCoreContainer {
         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(
+            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(),
+        ));
+
         Arc::new(Self {
             core_config: tracker_core_container.core_config.clone(),
             announce_handler: tracker_core_container.announce_handler.clone(),
@@ -49,6 +59,7 @@ impl HttpTrackerCoreContainer {
             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(),
         })
     }
 }

packages/http-tracker-core/src/services/announce.rs

@@ -83,81 +83,105 @@ impl From<authentication::key::Error> for HttpAnnounceError {
 /// > **NOTICE**: as the HTTP tracker does not requires a connection request
 /// > like the UDP tracker, the number of TCP connections is incremented for
 /// > each `announce` request.
-///
-/// # Errors
-///
-/// This function will return an error if:
-///
-/// - The tracker is running in `listed` mode and the torrent is not whitelisted.
-/// - There is an error when resolving the client IP address.
-#[allow(clippy::too_many_arguments)]
-pub async fn handle_announce(
-    core_config: &Arc<Core>,
-    announce_handler: &Arc<AnnounceHandler>,
-    authentication_service: &Arc<AuthenticationService>,
-    whitelist_authorization: &Arc<whitelist::authorization::WhitelistAuthorization>,
-    opt_http_stats_event_sender: &Arc<Option<Box<dyn statistics::event::sender::Sender>>>,
-    announce_request: &Announce,
-    client_ip_sources: &ClientIpSources,
-    maybe_key: Option<Key>,
-) -> Result<AnnounceData, HttpAnnounceError> {
-    // Authentication
-    if core_config.private {
-        match maybe_key {
-            Some(key) => match authentication_service.authenticate(&key).await {
-                Ok(()) => (),
-                Err(error) => return Err(error.into()),
-            },
-            None => {
-                return Err(authentication::key::Error::MissingAuthKey {
-                    location: Location::caller(),
+pub struct AnnounceService {
+    core_config: Arc<Core>,
+    announce_handler: Arc<AnnounceHandler>,
+    authentication_service: Arc<AuthenticationService>,
+    whitelist_authorization: Arc<whitelist::authorization::WhitelistAuthorization>,
+    opt_http_stats_event_sender: Arc<Option<Box<dyn statistics::event::sender::Sender>>>,
+}
+
+impl AnnounceService {
+    #[must_use]
+    pub fn new(
+        core_config: Arc<Core>,
+        announce_handler: Arc<AnnounceHandler>,
+        authentication_service: Arc<AuthenticationService>,
+        whitelist_authorization: Arc<whitelist::authorization::WhitelistAuthorization>,
+        opt_http_stats_event_sender: Arc<Option<Box<dyn statistics::event::sender::Sender>>>,
+    ) -> Self {
+        Self {
+            core_config,
+            announce_handler,
+            authentication_service,
+            whitelist_authorization,
+            opt_http_stats_event_sender,
+        }
+    }
+
+    /// Handles an announce request.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if:
+    ///
+    /// - The tracker is running in `listed` mode and the torrent is not whitelisted.
+    /// - There is an error when resolving the client IP address.
+    pub async fn handle_announce(
+        &self,
+        announce_request: &Announce,
+        client_ip_sources: &ClientIpSources,
+        maybe_key: Option<Key>,
+    ) -> Result<AnnounceData, HttpAnnounceError> {
+        // Authentication
+        if self.core_config.private {
+            match maybe_key {
+                Some(key) => match self.authentication_service.authenticate(&key).await {
+                    Ok(()) => (),
+                    Err(error) => return Err(error.into()),
+                },
+                None => {
+                    return Err(authentication::key::Error::MissingAuthKey {
+                        location: Location::caller(),
+                    }
+                    .into())
                 }
-                .into())
             }
         }
-    }
 
-    // Authorization
-    match whitelist_authorization.authorize(&announce_request.info_hash).await {
-        Ok(()) => (),
-        Err(error) => return Err(error.into()),
-    }
+        // Authorization
+        match self.whitelist_authorization.authorize(&announce_request.info_hash).await {
+            Ok(()) => (),
+            Err(error) => return Err(error.into()),
+        }
 
-    let peer_ip = match peer_ip_resolver::invoke(core_config.net.on_reverse_proxy, client_ip_sources) {
-        Ok(peer_ip) => peer_ip,
-        Err(error) => return Err(error.into()),
-    };
+        let peer_ip = match peer_ip_resolver::invoke(self.core_config.net.on_reverse_proxy, client_ip_sources) {
+            Ok(peer_ip) => peer_ip,
+            Err(error) => return Err(error.into()),
+        };
 
-    let mut peer = peer_from_request(announce_request, &peer_ip);
+        let mut peer = peer_from_request(announce_request, &peer_ip);
 
-    let peers_wanted = match announce_request.numwant {
-        Some(numwant) => PeersWanted::only(numwant),
-        None => PeersWanted::AsManyAsPossible,
-    };
+        let peers_wanted = match announce_request.numwant {
+            Some(numwant) => PeersWanted::only(numwant),
+            None => PeersWanted::AsManyAsPossible,
+        };
 
-    let original_peer_ip = peer.peer_addr.ip();
+        let original_peer_ip = peer.peer_addr.ip();
 
-    // The tracker could change the original peer ip
-    let announce_data = announce_handler
-        .announce(&announce_request.info_hash, &mut peer, &original_peer_ip, &peers_wanted)
-        .await?;
+        // The tracker could change the original peer ip
+        let announce_data = self
+            .announce_handler
+            .announce(&announce_request.info_hash, &mut peer, &original_peer_ip, &peers_wanted)
+            .await?;
 
-    if let Some(http_stats_event_sender) = opt_http_stats_event_sender.as_deref() {
-        match original_peer_ip {
-            IpAddr::V4(_) => {
-                http_stats_event_sender
-                    .send_event(statistics::event::Event::Tcp4Announce)
-                    .await;
-            }
-            IpAddr::V6(_) => {
-                http_stats_event_sender
-                    .send_event(statistics::event::Event::Tcp6Announce)
-                    .await;
+        if let Some(http_stats_event_sender) = self.opt_http_stats_event_sender.as_deref() {
+            match original_peer_ip {
+                IpAddr::V4(_) => {
+                    http_stats_event_sender
+                        .send_event(statistics::event::Event::Tcp4Announce)
+                        .await;
+                }
+                IpAddr::V6(_) => {
+                    http_stats_event_sender
+                        .send_event(statistics::event::Event::Tcp6Announce)
+                        .await;
+                }
             }
         }
-    }
 
-    Ok(announce_data)
+        Ok(announce_data)
+    }
 }
 
 #[cfg(test)]
@@ -302,11 +326,11 @@ mod tests {
         use torrust_tracker_test_helpers::configuration;
 
         use super::{sample_peer_using_ipv4, sample_peer_using_ipv6};
-        use crate::services::announce::handle_announce;
         use crate::services::announce::tests::{
             initialize_core_tracker_services, initialize_core_tracker_services_with_config, sample_announce_request_for_peer,
             sample_peer, MockHttpStatsEventSender,
         };
+        use crate::services::announce::AnnounceService;
         use crate::statistics;
 
         #[tokio::test]
@@ -317,18 +341,18 @@ mod tests {
 
             let (announce_request, client_ip_sources) = sample_announce_request_for_peer(peer);
 
-            let announce_data = handle_announce(
-                &core_tracker_services.core_config,
-                &core_tracker_services.announce_handler,
-                &core_tracker_services.authentication_service,
-                &core_tracker_services.whitelist_authorization,
-                &core_http_tracker_services.http_stats_event_sender,
-                &announce_request,
-                &client_ip_sources,
-                None,
-            )
-            .await
-            .unwrap();
+            let announce_service = AnnounceService::new(
+                core_tracker_services.core_config.clone(),
+                core_tracker_services.announce_handler.clone(),
+                core_tracker_services.authentication_service.clone(),
+                core_tracker_services.whitelist_authorization.clone(),
+                core_http_tracker_services.http_stats_event_sender.clone(),
+            );
+
+            let announce_data = announce_service
+                .handle_announce(&announce_request, &client_ip_sources, None)
+                .await
+                .unwrap();
 
             let expected_announce_data = AnnounceData {
                 peers: vec![],
@@ -361,18 +385,18 @@ mod tests {
 
             let (announce_request, client_ip_sources) = sample_announce_request_for_peer(peer);
 
-            let _announce_data = handle_announce(
-                &core_tracker_services.core_config,
-                &core_tracker_services.announce_handler,
-                &core_tracker_services.authentication_service,
-                &core_tracker_services.whitelist_authorization,
-                &core_http_tracker_services.http_stats_event_sender,
-                &announce_request,
-                &client_ip_sources,
-                None,
-            )
-            .await
-            .unwrap();
+            let announce_service = AnnounceService::new(
+                core_tracker_services.core_config.clone(),
+                core_tracker_services.announce_handler.clone(),
+                core_tracker_services.authentication_service.clone(),
+                core_tracker_services.whitelist_authorization.clone(),
+                core_http_tracker_services.http_stats_event_sender.clone(),
+            );
+
+            let _announce_data = announce_service
+                .handle_announce(&announce_request, &client_ip_sources, None)
+                .await
+                .unwrap();
         }
 
         fn tracker_with_an_ipv6_external_ip() -> Configuration {
@@ -413,18 +437,18 @@ mod tests {
 
             let (announce_request, client_ip_sources) = sample_announce_request_for_peer(peer);
 
-            let _announce_data = handle_announce(
-                &core_tracker_services.core_config,
-                &core_tracker_services.announce_handler,
-                &core_tracker_services.authentication_service,
-                &core_tracker_services.whitelist_authorization,
-                &core_http_tracker_services.http_stats_event_sender,
-                &announce_request,
-                &client_ip_sources,
-                None,
-            )
-            .await
-            .unwrap();
+            let announce_service = AnnounceService::new(
+                core_tracker_services.core_config.clone(),
+                core_tracker_services.announce_handler.clone(),
+                core_tracker_services.authentication_service.clone(),
+                core_tracker_services.whitelist_authorization.clone(),
+                core_http_tracker_services.http_stats_event_sender.clone(),
+            );
+
+            let _announce_data = announce_service
+                .handle_announce(&announce_request, &client_ip_sources, None)
+                .await
+                .unwrap();
         }
 
         #[tokio::test]
@@ -446,18 +470,18 @@ mod tests {
 
             let (announce_request, client_ip_sources) = sample_announce_request_for_peer(peer);
 
-            let _announce_data = handle_announce(
-                &core_tracker_services.core_config,
-                &core_tracker_services.announce_handler,
-                &core_tracker_services.authentication_service,
-                &core_tracker_services.whitelist_authorization,
-                &core_http_tracker_services.http_stats_event_sender,
-                &announce_request,
-                &client_ip_sources,
-                None,
-            )
-            .await
-            .unwrap();
+            let announce_service = AnnounceService::new(
+                core_tracker_services.core_config.clone(),
+                core_tracker_services.announce_handler.clone(),
+                core_tracker_services.authentication_service.clone(),
+                core_tracker_services.whitelist_authorization.clone(),
+                core_http_tracker_services.http_stats_event_sender.clone(),
+            );
+
+            let _announce_data = announce_service
+                .handle_announce(&announce_request, &client_ip_sources, None)
+                .await
+                .unwrap();
         }
     }
 }

src/container.rs

@@ -1,6 +1,7 @@
 use std::sync::Arc;
 
 use bittorrent_http_tracker_core::container::HttpTrackerCoreContainer;
+use bittorrent_http_tracker_core::services::announce::AnnounceService;
 use bittorrent_tracker_core::announce_handler::AnnounceHandler;
 use bittorrent_tracker_core::authentication::handler::KeysHandler;
 use bittorrent_tracker_core::authentication::service::AuthenticationService;
@@ -45,6 +46,7 @@ pub struct AppContainer {
     // HTTP Tracker Core Services
     pub http_stats_event_sender: Arc<Option<Box<dyn bittorrent_http_tracker_core::statistics::event::sender::Sender>>>,
     pub http_stats_repository: Arc<bittorrent_http_tracker_core::statistics::repository::Repository>,
+    pub http_announce_service: Arc<bittorrent_http_tracker_core::services::announce::AnnounceService>,
 
     // UDP Tracker Server Services
     pub udp_server_stats_event_sender: Arc<Option<Box<dyn torrust_udp_tracker_server::statistics::event::sender::Sender>>>,
@@ -58,27 +60,35 @@ impl AppContainer {
 
         let tracker_core_container = TrackerCoreContainer::initialize(&core_config);
 
-        // HTTP core stats
+        // HTTP Tracker Core Services
         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);
-
-        // UDP core stats
+        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(),
+        ));
+
+        // UDP Tracker Core Services
         let (udp_core_stats_event_sender, udp_core_stats_repository) =
             bittorrent_udp_tracker_core::statistics::setup::factory(configuration.core.tracker_usage_statistics);
         let udp_core_stats_event_sender = Arc::new(udp_core_stats_event_sender);
         let udp_core_stats_repository = Arc::new(udp_core_stats_repository);
 
         let ban_service = Arc::new(RwLock::new(BanService::new(MAX_CONNECTION_ID_ERRORS_PER_IP)));
 
-        // UDP server stats
+        // UDP Tracker Server Services
         let (udp_server_stats_event_sender, udp_server_stats_repository) =
             torrust_udp_tracker_server::statistics::setup::factory(configuration.core.tracker_usage_statistics);
         let udp_server_stats_event_sender = Arc::new(udp_server_stats_event_sender);
         let udp_server_stats_repository = Arc::new(udp_server_stats_repository);
 
         AppContainer {
+            // Tracker Core Services
             core_config,
             database: tracker_core_container.database,
             announce_handler: tracker_core_container.announce_handler,
@@ -91,11 +101,18 @@ impl AppContainer {
             in_memory_torrent_repository: tracker_core_container.in_memory_torrent_repository,
             db_torrent_repository: tracker_core_container.db_torrent_repository,
             torrents_manager: tracker_core_container.torrents_manager,
+
+            // UDP Tracker Core Services
             ban_service,
-            http_stats_event_sender,
             udp_core_stats_event_sender,
-            http_stats_repository,
             udp_core_stats_repository,
+
+            // HTTP Tracker Core Services
+            http_stats_event_sender,
+            http_stats_repository,
+            http_announce_service,
+
+            // UDP Tracker Server Services
             udp_server_stats_event_sender,
             udp_server_stats_repository,
         }
@@ -113,6 +130,7 @@ impl AppContainer {
             http_tracker_config: http_tracker_config.clone(),
             http_stats_event_sender: self.http_stats_event_sender.clone(),
             http_stats_repository: self.http_stats_repository.clone(),
+            announce_service: self.http_announce_service.clone(),
         }
     }