refactor: [torrust#1268] move announce logic from udp server to udp_tracker_core package

Author: josecelano

src/packages/udp_tracker_core/mod.rs

@@ -1,2 +1,3 @@
+pub mod peer_builder;
 pub mod services;
 pub mod statistics;

src/servers/udp/peer_builder.rs src/packages/udp_tracker_core/peer_builder.rs

@@ -7,15 +7,55 @@
 //!
 //! It also sends an [`udp_tracker_core::statistics::event::Event`]
 //! because events are specific for the HTTP tracker.
-use std::net::IpAddr;
+use std::net::{IpAddr, SocketAddr};
 use std::sync::Arc;
 
+use aquatic_udp_protocol::AnnounceRequest;
 use bittorrent_primitives::info_hash::InfoHash;
 use bittorrent_tracker_core::announce_handler::{AnnounceHandler, PeersWanted};
+use bittorrent_tracker_core::error::WhitelistError;
+use bittorrent_tracker_core::whitelist;
 use torrust_tracker_primitives::core::AnnounceData;
 use torrust_tracker_primitives::peer;
 
-use crate::packages::udp_tracker_core;
+use crate::packages::udp_tracker_core::{self, peer_builder};
+
+/// It handles the `Announce` request.
+///
+/// # Errors
+///
+/// It will return an error if:
+///
+/// - The tracker is running in listed mode and the torrent is not in the
+///   whitelist.
+#[allow(clippy::too_many_arguments)]
+pub async fn handle_announce(
+    remote_addr: SocketAddr,
+    request: &AnnounceRequest,
+    announce_handler: &Arc<AnnounceHandler>,
+    whitelist_authorization: &Arc<whitelist::authorization::WhitelistAuthorization>,
+    opt_udp_stats_event_sender: &Arc<Option<Box<dyn udp_tracker_core::statistics::event::sender::Sender>>>,
+) -> Result<AnnounceData, WhitelistError> {
+    let info_hash = request.info_hash.into();
+    let remote_client_ip = remote_addr.ip();
+
+    // Authorization
+    whitelist_authorization.authorize(&info_hash).await?;
+
+    let mut peer = peer_builder::from_request(request, &remote_client_ip);
+    let peers_wanted: PeersWanted = i32::from(request.peers_wanted.0).into();
+
+    let announce_data = invoke(
+        announce_handler.clone(),
+        opt_udp_stats_event_sender.clone(),
+        info_hash,
+        &mut peer,
+        &peers_wanted,
+    )
+    .await;
+
+    Ok(announce_data)
+}
 
 pub async fn invoke(
     announce_handler: Arc<AnnounceHandler>,

src/packages/udp_tracker_core/services/announce.rs

@@ -8,17 +8,16 @@ use aquatic_udp_protocol::{
     Port, Response, ResponsePeer, TransactionId,
 };
 use bittorrent_primitives::info_hash::InfoHash;
-use bittorrent_tracker_core::announce_handler::{AnnounceHandler, PeersWanted};
+use bittorrent_tracker_core::announce_handler::AnnounceHandler;
 use bittorrent_tracker_core::whitelist;
 use torrust_tracker_configuration::Core;
 use tracing::{instrument, Level};
 use zerocopy::network_endian::I32;
 
-use crate::packages::udp_tracker_core::{self, services};
+use crate::packages::udp_tracker_core::{self};
 use crate::servers::udp::connection_cookie::check;
 use crate::servers::udp::error::Error;
 use crate::servers::udp::handlers::gen_remote_fingerprint;
-use crate::servers::udp::peer_builder;
 
 /// It handles the `Announce` request. Refer to [`Announce`](crate::servers::udp#announce)
 /// request for more information.
@@ -44,36 +43,29 @@ pub async fn handle_announce(
 
     tracing::trace!("handle announce");
 
+    // todo: move authentication to `udp_tracker_core::services::announce::handle_announce`
+
     check(
         &request.connection_id,
         gen_remote_fingerprint(&remote_addr),
         cookie_valid_range,
     )
     .map_err(|e| (e, request.transaction_id))?;
 
-    let info_hash = request.info_hash.into();
-    let remote_client_ip = remote_addr.ip();
-
-    // Authorization
-    whitelist_authorization
-        .authorize(&info_hash)
-        .await
-        .map_err(|e| Error::TrackerError {
-            source: (Arc::new(e) as Arc<dyn std::error::Error + Send + Sync>).into(),
-        })
-        .map_err(|e| (e, request.transaction_id))?;
-
-    let mut peer = peer_builder::from_request(request, &remote_client_ip);
-    let peers_wanted: PeersWanted = i32::from(request.peers_wanted.0).into();
-
-    let response = services::announce::invoke(
-        announce_handler.clone(),
-        opt_udp_stats_event_sender.clone(),
-        info_hash,
-        &mut peer,
-        &peers_wanted,
+    let response = udp_tracker_core::services::announce::handle_announce(
+        remote_addr,
+        request,
+        announce_handler,
+        whitelist_authorization,
+        opt_udp_stats_event_sender,
     )
-    .await;
+    .await
+    .map_err(|e| Error::TrackerError {
+        source: (Arc::new(e) as Arc<dyn std::error::Error + Send + Sync>).into(),
+    })
+    .map_err(|e| (e, request.transaction_id))?;
+
+    // todo: extract `build_response` function.
 
     #[allow(clippy::cast_possible_truncation)]
     if remote_addr.is_ipv4() {

src/servers/udp/handlers/announce.rs

@@ -640,7 +640,6 @@ use std::net::SocketAddr;
 pub mod connection_cookie;
 pub mod error;
 pub mod handlers;
-pub mod peer_builder;
 pub mod server;
 
 pub const UDP_TRACKER_LOG_TARGET: &str = "UDP TRACKER";