refactor: exatract response builders for UDP handlers

Author: josecelano

src/servers/udp/handlers/announce.rs

@@ -11,6 +11,7 @@ use bittorrent_primitives::info_hash::InfoHash;
 use bittorrent_tracker_core::announce_handler::AnnounceHandler;
 use bittorrent_tracker_core::whitelist;
 use torrust_tracker_configuration::Core;
+use torrust_tracker_primitives::core::AnnounceData;
 use tracing::{instrument, Level};
 use zerocopy::network_endian::I32;
 
@@ -41,7 +42,7 @@ pub async fn handle_announce(
 
     tracing::trace!("handle announce");
 
-    let response = udp_tracker_core::services::announce::handle_announce(
+    let announce_data = udp_tracker_core::services::announce::handle_announce(
         remote_addr,
         request,
         announce_handler,
@@ -52,18 +53,25 @@ pub async fn handle_announce(
     .await
     .map_err(|e| (e.into(), request.transaction_id))?;
 
-    // todo: extract `build_response` function.
+    Ok(build_response(remote_addr, request, core_config, &announce_data))
+}
 
+fn build_response(
+    remote_addr: SocketAddr,
+    request: &AnnounceRequest,
+    core_config: &Arc<Core>,
+    announce_data: &AnnounceData,
+) -> Response {
     #[allow(clippy::cast_possible_truncation)]
     if remote_addr.is_ipv4() {
         let announce_response = AnnounceResponse {
             fixed: AnnounceResponseFixedData {
                 transaction_id: request.transaction_id,
                 announce_interval: AnnounceInterval(I32::new(i64::from(core_config.announce_policy.interval) as i32)),
-                leechers: NumberOfPeers(I32::new(i64::from(response.stats.incomplete) as i32)),
-                seeders: NumberOfPeers(I32::new(i64::from(response.stats.complete) as i32)),
+                leechers: NumberOfPeers(I32::new(i64::from(announce_data.stats.incomplete) as i32)),
+                seeders: NumberOfPeers(I32::new(i64::from(announce_data.stats.complete) as i32)),
             },
-            peers: response
+            peers: announce_data
                 .peers
                 .iter()
                 .filter_map(|peer| {
@@ -79,16 +87,16 @@ pub async fn handle_announce(
                 .collect(),
         };
 
-        Ok(Response::from(announce_response))
+        Response::from(announce_response)
     } else {
         let announce_response = AnnounceResponse {
             fixed: AnnounceResponseFixedData {
                 transaction_id: request.transaction_id,
                 announce_interval: AnnounceInterval(I32::new(i64::from(core_config.announce_policy.interval) as i32)),
-                leechers: NumberOfPeers(I32::new(i64::from(response.stats.incomplete) as i32)),
-                seeders: NumberOfPeers(I32::new(i64::from(response.stats.complete) as i32)),
+                leechers: NumberOfPeers(I32::new(i64::from(announce_data.stats.incomplete) as i32)),
+                seeders: NumberOfPeers(I32::new(i64::from(announce_data.stats.complete) as i32)),
             },
-            peers: response
+            peers: announce_data
                 .peers
                 .iter()
                 .filter_map(|peer| {
@@ -104,7 +112,7 @@ pub async fn handle_announce(
                 .collect(),
         };
 
-        Ok(Response::from(announce_response))
+        Response::from(announce_response)
     }
 }
 

src/servers/udp/handlers/connect.rs

@@ -2,7 +2,7 @@
 use std::net::SocketAddr;
 use std::sync::Arc;
 
-use aquatic_udp_protocol::{ConnectRequest, ConnectResponse, Response};
+use aquatic_udp_protocol::{ConnectRequest, ConnectResponse, ConnectionId, Response};
 use tracing::{instrument, Level};
 
 use crate::packages::udp_tracker_core;
@@ -25,12 +25,9 @@ pub async fn handle_connect(
 
     tracing::trace!("handle connect");
 
-    let connection_id = make(gen_remote_fingerprint(&remote_addr), cookie_issue_time).expect("it should be a normal value");
+    // todo: move to connect service in udp_tracker_core
 
-    let response = ConnectResponse {
-        transaction_id: request.transaction_id,
-        connection_id,
-    };
+    let connection_id = make(gen_remote_fingerprint(&remote_addr), cookie_issue_time).expect("it should be a normal value");
 
     if let Some(udp_stats_event_sender) = opt_udp_stats_event_sender.as_deref() {
         match remote_addr {
@@ -47,6 +44,15 @@ pub async fn handle_connect(
         }
     }
 
+    build_response(*request, connection_id)
+}
+
+fn build_response(request: ConnectRequest, connection_id: ConnectionId) -> Response {
+    let response = ConnectResponse {
+        transaction_id: request.transaction_id,
+        connection_id,
+    };
+
     Response::from(response)
 }
 

src/servers/udp/handlers/scrape.rs

@@ -7,6 +7,7 @@ use aquatic_udp_protocol::{
     NumberOfDownloads, NumberOfPeers, Response, ScrapeRequest, ScrapeResponse, TorrentScrapeStatistics, TransactionId,
 };
 use bittorrent_tracker_core::scrape_handler::ScrapeHandler;
+use torrust_tracker_primitives::core::ScrapeData;
 use tracing::{instrument, Level};
 use zerocopy::network_endian::I32;
 
@@ -43,8 +44,10 @@ pub async fn handle_scrape(
     .await
     .map_err(|e| (e.into(), request.transaction_id))?;
 
-    // todo: extract `build_response` function.
+    Ok(build_response(request, &scrape_data))
+}
 
+fn build_response(request: &ScrapeRequest, scrape_data: &ScrapeData) -> Response {
     let mut torrent_stats: Vec<TorrentScrapeStatistics> = Vec::new();
 
     for file in &scrape_data.files {
@@ -67,7 +70,7 @@ pub async fn handle_scrape(
         torrent_stats,
     };
 
-    Ok(Response::from(response))
+    Response::from(response)
 }
 
 #[cfg(test)]