refactor: [torrust#1319] remove UDP server events from UDP tracker core package

Some events were moved from the `udp-tracker-core` package to the
`udp-tracker-server` package.

This commits remmoves the unused events from the `udp-tracker-core`.

Author: josecelano

packages/axum-tracker-api-server/src/v1/context/stats/routes.rs

@@ -19,7 +19,7 @@ pub fn add(prefix: &str, router: Router, http_api_container: &Arc<TrackerHttpApi
             http_api_container.in_memory_torrent_repository.clone(),
             http_api_container.ban_service.clone(),
             http_api_container.http_stats_repository.clone(),
-            http_api_container.udp_stats_repository.clone(),
+            http_api_container.udp_core_stats_repository.clone(),
         )),
     )
 }

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

@@ -23,7 +23,7 @@ pub struct TrackerHttpApiCoreContainer {
 
     // todo: replace with UdpTrackerCoreContainer
     pub ban_service: Arc<RwLock<BanService>>,
-    pub udp_stats_repository: Arc<bittorrent_udp_tracker_core::statistics::repository::Repository>,
+    pub udp_core_stats_repository: Arc<bittorrent_udp_tracker_core::statistics::repository::Repository>,
 
     pub http_api_config: Arc<HttpApi>,
 }
@@ -64,7 +64,7 @@ impl TrackerHttpApiCoreContainer {
             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(),
+            udp_core_stats_repository: udp_tracker_core_container.udp_core_stats_repository.clone(),
 
             http_api_config: http_api_config.clone(),
         })

packages/tracker-api-core/src/statistics/services.rs

@@ -27,12 +27,12 @@ pub async fn get_metrics(
     in_memory_torrent_repository: Arc<InMemoryTorrentRepository>,
     ban_service: Arc<RwLock<BanService>>,
     http_stats_repository: Arc<bittorrent_http_tracker_core::statistics::repository::Repository>,
-    udp_stats_repository: Arc<statistics::repository::Repository>,
+    udp_core_stats_repository: Arc<statistics::repository::Repository>,
 ) -> TrackerMetrics {
     let torrents_metrics = in_memory_torrent_repository.get_torrents_metrics();
     let udp_banned_ips_total = ban_service.read().await.get_banned_ips_total();
     let http_stats = http_stats_repository.get_stats().await;
-    let udp_stats = udp_stats_repository.get_stats().await;
+    let udp_stats = udp_core_stats_repository.get_stats().await;
 
     TrackerMetrics {
         torrents_metrics,
@@ -103,15 +103,15 @@ mod tests {
         let http_stats_repository = Arc::new(http_stats_repository);
 
         // UDP stats
-        let (_udp_stats_event_sender, udp_stats_repository) =
+        let (_udp_core_stats_event_sender, udp_core_stats_repository) =
             bittorrent_udp_tracker_core::statistics::setup::factory(config.core.tracker_usage_statistics);
-        let udp_stats_repository = Arc::new(udp_stats_repository);
+        let udp_core_stats_repository = Arc::new(udp_core_stats_repository);
 
         let tracker_metrics = get_metrics(
             in_memory_torrent_repository.clone(),
             ban_service.clone(),
             http_stats_repository.clone(),
-            udp_stats_repository.clone(),
+            udp_core_stats_repository.clone(),
         )
         .await;
 

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

@@ -18,8 +18,8 @@ pub struct UdpTrackerCoreContainer {
     pub whitelist_authorization: Arc<whitelist::authorization::WhitelistAuthorization>,
 
     pub udp_tracker_config: Arc<UdpTracker>,
-    pub udp_stats_event_sender: Arc<Option<Box<dyn statistics::event::sender::Sender>>>,
-    pub udp_stats_repository: Arc<statistics::repository::Repository>,
+    pub udp_core_stats_event_sender: Arc<Option<Box<dyn statistics::event::sender::Sender>>>,
+    pub udp_core_stats_repository: Arc<statistics::repository::Repository>,
     pub ban_service: Arc<RwLock<BanService>>,
 }
 
@@ -35,10 +35,10 @@ impl UdpTrackerCoreContainer {
         tracker_core_container: &Arc<TrackerCoreContainer>,
         udp_tracker_config: &Arc<UdpTracker>,
     ) -> Arc<UdpTrackerCoreContainer> {
-        let (udp_stats_event_sender, udp_stats_repository) =
+        let (udp_core_stats_event_sender, udp_core_stats_repository) =
             statistics::setup::factory(tracker_core_container.core_config.tracker_usage_statistics);
-        let udp_stats_event_sender = Arc::new(udp_stats_event_sender);
-        let udp_stats_repository = Arc::new(udp_stats_repository);
+        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)));
 
@@ -49,8 +49,8 @@ impl UdpTrackerCoreContainer {
             whitelist_authorization: tracker_core_container.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(),
+            udp_core_stats_event_sender: udp_core_stats_event_sender.clone(),
+            udp_core_stats_repository: udp_core_stats_repository.clone(),
             ban_service: ban_service.clone(),
         })
     }

packages/udp-tracker-core/src/services/connect.rs

@@ -55,10 +55,10 @@ mod tests {
 
         #[tokio::test]
         async fn a_connect_response_should_contain_the_same_transaction_id_as_the_connect_request() {
-            let (udp_stats_event_sender, _udp_stats_repository) = statistics::setup::factory(false);
-            let udp_stats_event_sender = Arc::new(udp_stats_event_sender);
+            let (udp_core_stats_event_sender, _udp_core_stats_repository) = statistics::setup::factory(false);
+            let udp_core_stats_event_sender = Arc::new(udp_core_stats_event_sender);
 
-            let response = handle_connect(sample_ipv4_remote_addr(), &udp_stats_event_sender, sample_issue_time()).await;
+            let response = handle_connect(sample_ipv4_remote_addr(), &udp_core_stats_event_sender, sample_issue_time()).await;
 
             assert_eq!(
                 response,
@@ -68,10 +68,10 @@ mod tests {
 
         #[tokio::test]
         async fn a_connect_response_should_contain_a_new_connection_id() {
-            let (udp_stats_event_sender, _udp_stats_repository) = statistics::setup::factory(false);
-            let udp_stats_event_sender = Arc::new(udp_stats_event_sender);
+            let (udp_core_stats_event_sender, _udp_core_stats_repository) = statistics::setup::factory(false);
+            let udp_core_stats_event_sender = Arc::new(udp_core_stats_event_sender);
 
-            let response = handle_connect(sample_ipv4_remote_addr(), &udp_stats_event_sender, sample_issue_time()).await;
+            let response = handle_connect(sample_ipv4_remote_addr(), &udp_core_stats_event_sender, sample_issue_time()).await;
 
             assert_eq!(
                 response,
@@ -81,10 +81,10 @@ mod tests {
 
         #[tokio::test]
         async fn a_connect_response_should_contain_a_new_connection_id_ipv6() {
-            let (udp_stats_event_sender, _udp_stats_repository) = statistics::setup::factory(false);
-            let udp_stats_event_sender = Arc::new(udp_stats_event_sender);
+            let (udp_core_stats_event_sender, _udp_core_stats_repository) = statistics::setup::factory(false);
+            let udp_core_stats_event_sender = Arc::new(udp_core_stats_event_sender);
 
-            let response = handle_connect(sample_ipv6_remote_addr(), &udp_stats_event_sender, sample_issue_time()).await;
+            let response = handle_connect(sample_ipv6_remote_addr(), &udp_core_stats_event_sender, sample_issue_time()).await;
 
             assert_eq!(
                 response,

packages/udp-tracker-core/src/statistics/event/handler.rs

@@ -1,20 +1,9 @@
-use crate::statistics::event::{Event, UdpResponseKind};
+use crate::statistics::event::Event;
 use crate::statistics::repository::Repository;
 
 pub async fn handle_event(event: Event, stats_repository: &Repository) {
     match event {
-        // UDP
-        Event::UdpRequestAborted => {
-            stats_repository.increase_udp_requests_aborted().await;
-        }
-        Event::UdpRequestBanned => {
-            stats_repository.increase_udp_requests_banned().await;
-        }
-
         // UDP4
-        Event::Udp4Request => {
-            stats_repository.increase_udp4_requests().await;
-        }
         Event::Udp4Connect => {
             stats_repository.increase_udp4_connections().await;
         }
@@ -24,39 +13,8 @@ pub async fn handle_event(event: Event, stats_repository: &Repository) {
         Event::Udp4Scrape => {
             stats_repository.increase_udp4_scrapes().await;
         }
-        Event::Udp4Response {
-            kind,
-            req_processing_time,
-        } => {
-            stats_repository.increase_udp4_responses().await;
-
-            match kind {
-                UdpResponseKind::Connect => {
-                    stats_repository
-                        .recalculate_udp_avg_connect_processing_time_ns(req_processing_time)
-                        .await;
-                }
-                UdpResponseKind::Announce => {
-                    stats_repository
-                        .recalculate_udp_avg_announce_processing_time_ns(req_processing_time)
-                        .await;
-                }
-                UdpResponseKind::Scrape => {
-                    stats_repository
-                        .recalculate_udp_avg_scrape_processing_time_ns(req_processing_time)
-                        .await;
-                }
-                UdpResponseKind::Error => {}
-            }
-        }
-        Event::Udp4Error => {
-            stats_repository.increase_udp4_errors().await;
-        }
 
         // UDP6
-        Event::Udp6Request => {
-            stats_repository.increase_udp6_requests().await;
-        }
         Event::Udp6Connect => {
             stats_repository.increase_udp6_connections().await;
         }
@@ -66,15 +24,6 @@ pub async fn handle_event(event: Event, stats_repository: &Repository) {
         Event::Udp6Scrape => {
             stats_repository.increase_udp6_scrapes().await;
         }
-        Event::Udp6Response {
-            kind: _,
-            req_processing_time: _,
-        } => {
-            stats_repository.increase_udp6_responses().await;
-        }
-        Event::Udp6Error => {
-            stats_repository.increase_udp6_errors().await;
-        }
     }
 
     tracing::debug!("stats: {:?}", stats_repository.get_stats().await);
@@ -151,100 +100,4 @@ mod tests {
 
         assert_eq!(stats.udp6_scrapes_handled, 1);
     }
-
-    #[tokio::test]
-    async fn should_increase_the_udp_abort_counter_when_it_receives_a_udp_abort_event() {
-        let stats_repository = Repository::new();
-
-        handle_event(Event::UdpRequestAborted, &stats_repository).await;
-        let stats = stats_repository.get_stats().await;
-        assert_eq!(stats.udp_requests_aborted, 1);
-    }
-    #[tokio::test]
-    async fn should_increase_the_udp_ban_counter_when_it_receives_a_udp_banned_event() {
-        let stats_repository = Repository::new();
-
-        handle_event(Event::UdpRequestBanned, &stats_repository).await;
-        let stats = stats_repository.get_stats().await;
-        assert_eq!(stats.udp_requests_banned, 1);
-    }
-
-    #[tokio::test]
-    async fn should_increase_the_udp4_requests_counter_when_it_receives_a_udp4_request_event() {
-        let stats_repository = Repository::new();
-
-        handle_event(Event::Udp4Request, &stats_repository).await;
-
-        let stats = stats_repository.get_stats().await;
-
-        assert_eq!(stats.udp4_requests, 1);
-    }
-
-    #[tokio::test]
-    async fn should_increase_the_udp4_responses_counter_when_it_receives_a_udp4_response_event() {
-        let stats_repository = Repository::new();
-
-        handle_event(
-            Event::Udp4Response {
-                kind: crate::statistics::event::UdpResponseKind::Announce,
-                req_processing_time: std::time::Duration::from_secs(1),
-            },
-            &stats_repository,
-        )
-        .await;
-
-        let stats = stats_repository.get_stats().await;
-
-        assert_eq!(stats.udp4_responses, 1);
-    }
-
-    #[tokio::test]
-    async fn should_increase_the_udp4_errors_counter_when_it_receives_a_udp4_error_event() {
-        let stats_repository = Repository::new();
-
-        handle_event(Event::Udp4Error, &stats_repository).await;
-
-        let stats = stats_repository.get_stats().await;
-
-        assert_eq!(stats.udp4_errors_handled, 1);
-    }
-
-    #[tokio::test]
-    async fn should_increase_the_udp6_requests_counter_when_it_receives_a_udp6_request_event() {
-        let stats_repository = Repository::new();
-
-        handle_event(Event::Udp6Request, &stats_repository).await;
-
-        let stats = stats_repository.get_stats().await;
-
-        assert_eq!(stats.udp6_requests, 1);
-    }
-
-    #[tokio::test]
-    async fn should_increase_the_udp6_response_counter_when_it_receives_a_udp6_response_event() {
-        let stats_repository = Repository::new();
-
-        handle_event(
-            Event::Udp6Response {
-                kind: crate::statistics::event::UdpResponseKind::Announce,
-                req_processing_time: std::time::Duration::from_secs(1),
-            },
-            &stats_repository,
-        )
-        .await;
-
-        let stats = stats_repository.get_stats().await;
-
-        assert_eq!(stats.udp6_responses, 1);
-    }
-    #[tokio::test]
-    async fn should_increase_the_udp6_errors_counter_when_it_receives_a_udp6_error_event() {
-        let stats_repository = Repository::new();
-
-        handle_event(Event::Udp6Error, &stats_repository).await;
-
-        let stats = stats_repository.get_stats().await;
-
-        assert_eq!(stats.udp6_errors_handled, 1);
-    }
 }

packages/udp-tracker-core/src/statistics/event/mod.rs

@@ -1,5 +1,3 @@
-use std::time::Duration;
-
 pub mod handler;
 pub mod listener;
 pub mod sender;
@@ -16,32 +14,10 @@ pub mod sender;
 pub enum Event {
     // code-review: consider one single event for request type with data: Event::Announce { scheme: HTTPorUDP, ip_version: V4orV6 }
     // Attributes are enums too.
-    UdpRequestAborted,
-    UdpRequestBanned,
-    Udp4Request,
     Udp4Connect,
     Udp4Announce,
     Udp4Scrape,
-    Udp4Response {
-        kind: UdpResponseKind,
-        req_processing_time: Duration,
-    },
-    Udp4Error,
-    Udp6Request,
     Udp6Connect,
     Udp6Announce,
     Udp6Scrape,
-    Udp6Response {
-        kind: UdpResponseKind,
-        req_processing_time: Duration,
-    },
-    Udp6Error,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum UdpResponseKind {
-    Connect,
-    Announce,
-    Scrape,
-    Error,
 }

packages/udp-tracker-core/src/statistics/services.rs

@@ -124,13 +124,14 @@ mod tests {
         let in_memory_torrent_repository = Arc::new(InMemoryTorrentRepository::default());
         let ban_service = Arc::new(RwLock::new(BanService::new(MAX_CONNECTION_ID_ERRORS_PER_IP)));
 
-        let (_udp_stats_event_sender, udp_stats_repository) = statistics::setup::factory(config.core.tracker_usage_statistics);
-        let udp_stats_repository = Arc::new(udp_stats_repository);
+        let (_udp_core_stats_event_sender, udp_core_stats_repository) =
+            statistics::setup::factory(config.core.tracker_usage_statistics);
+        let udp_core_stats_repository = Arc::new(udp_core_stats_repository);
 
         let tracker_metrics = get_metrics(
             in_memory_torrent_repository.clone(),
             ban_service.clone(),
-            udp_stats_repository.clone(),
+            udp_core_stats_repository.clone(),
         )
         .await;