refactor: [#1382] include req kin in UDP error response if it's known

It could be unkown if the request couldb be parsed succesfully.

Author: josecelano

packages/udp-tracker-server/src/handlers/announce.rs

@@ -32,7 +32,7 @@ pub async fn handle_announce(
     core_config: &Arc<Core>,
     opt_udp_server_stats_event_sender: &Arc<Option<Box<dyn server_statistics::event::sender::Sender>>>,
     cookie_valid_range: Range<f64>,
-) -> Result<Response, (Error, TransactionId)> {
+) -> Result<Response, (Error, TransactionId, UdpRequestKind)> {
     tracing::Span::current()
         .record("transaction_id", request.transaction_id.0.to_string())
         .record("connection_id", request.connection_id.0.to_string())
@@ -52,7 +52,7 @@ pub async fn handle_announce(
     let announce_data = announce_service
         .handle_announce(client_socket_addr, server_socket_addr, request, cookie_valid_range)
         .await
-        .map_err(|e| (e.into(), request.transaction_id))?;
+        .map_err(|e| (e.into(), request.transaction_id, UdpRequestKind::Announce))?;
 
     Ok(build_response(client_socket_addr, request, core_config, &announce_data))
 }

packages/udp-tracker-server/src/handlers/error.rs

@@ -12,11 +12,12 @@ use zerocopy::network_endian::I32;
 
 use crate::error::Error;
 use crate::statistics as server_statistics;
-use crate::statistics::event::ConnectionContext;
+use crate::statistics::event::{ConnectionContext, UdpRequestKind};
 
 #[allow(clippy::too_many_arguments)]
 #[instrument(fields(transaction_id), skip(opt_udp_server_stats_event_sender), ret(level = Level::TRACE))]
 pub async fn handle_error(
+    req_kind: Option<UdpRequestKind>,
     client_socket_addr: SocketAddr,
     server_socket_addr: SocketAddr,
     request_id: Uuid,

packages/udp-tracker-server/src/handlers/mod.rs

@@ -24,6 +24,7 @@ use uuid::Uuid;
 use super::RawRequest;
 use crate::container::UdpTrackerServerContainer;
 use crate::error::Error;
+use crate::statistics::event::UdpRequestKind;
 use crate::CurrentClock;
 
 #[derive(Debug, Clone, PartialEq)]
@@ -60,15 +61,15 @@ pub(crate) async fn handle_packet(
     udp_tracker_server_container: Arc<UdpTrackerServerContainer>,
     server_socket_addr: SocketAddr,
     cookie_time_values: CookieTimeValues,
-) -> Response {
+) -> (Response, Option<UdpRequestKind>) {
     let request_id = Uuid::new_v4();
 
     tracing::Span::current().record("request_id", request_id.to_string());
     tracing::debug!("Handling Packets: {udp_request:?}");
 
     let start_time = Instant::now();
 
-    let response =
+    let (response, opt_req_kind) =
         match Request::parse_bytes(&udp_request.payload[..udp_request.payload.len()], MAX_SCRAPE_TORRENTS).map_err(Error::from) {
             Ok(request) => match handle_request(
                 request,
@@ -80,8 +81,8 @@ pub(crate) async fn handle_packet(
             )
             .await
             {
-                Ok(response) => return response,
-                Err((error, transaction_id)) => {
+                Ok((response, req_kid)) => return (response, Some(req_kid)),
+                Err((error, transaction_id, req_kind)) => {
                     if let Error::UdpAnnounceError {
                         source: UdpAnnounceError::ConnectionCookieError { .. },
                     } = error
@@ -91,7 +92,8 @@ pub(crate) async fn handle_packet(
                         ban_service.increase_counter(&udp_request.from.ip());
                     }
 
-                    handle_error(
+                    let response = handle_error(
+                        Some(req_kind.clone()),
                         udp_request.from,
                         server_socket_addr,
                         request_id,
@@ -100,11 +102,14 @@ pub(crate) async fn handle_packet(
                         &error,
                         Some(transaction_id),
                     )
-                    .await
+                    .await;
+
+                    (response, Some(req_kind))
                 }
             },
             Err(e) => {
-                handle_error(
+                let response = handle_error(
+                    None,
                     udp_request.from,
                     server_socket_addr,
                     request_id,
@@ -113,14 +118,16 @@ pub(crate) async fn handle_packet(
                     &e,
                     None,
                 )
-                .await
+                .await;
+
+                (response, None)
             }
         };
 
     let latency = start_time.elapsed();
     tracing::trace!(?latency, "responded");
 
-    response
+    (response, opt_req_kind)
 }
 
 /// It dispatches the request to the correct handler.
@@ -143,21 +150,24 @@ pub async fn handle_request(
     udp_tracker_core_container: Arc<UdpTrackerCoreContainer>,
     udp_tracker_server_container: Arc<UdpTrackerServerContainer>,
     cookie_time_values: CookieTimeValues,
-) -> Result<Response, (Error, TransactionId)> {
+) -> Result<(Response, UdpRequestKind), (Error, TransactionId, UdpRequestKind)> {
     tracing::trace!("handle request");
 
     match request {
-        Request::Connect(connect_request) => Ok(handle_connect(
-            client_socket_addr,
-            server_socket_addr,
-            &connect_request,
-            &udp_tracker_core_container.connect_service,
-            &udp_tracker_server_container.udp_server_stats_event_sender,
-            cookie_time_values.issue_time,
-        )
-        .await),
+        Request::Connect(connect_request) => Ok((
+            handle_connect(
+                client_socket_addr,
+                server_socket_addr,
+                &connect_request,
+                &udp_tracker_core_container.connect_service,
+                &udp_tracker_server_container.udp_server_stats_event_sender,
+                cookie_time_values.issue_time,
+            )
+            .await,
+            UdpRequestKind::Connect,
+        )),
         Request::Announce(announce_request) => {
-            handle_announce(
+            match handle_announce(
                 &udp_tracker_core_container.announce_service,
                 client_socket_addr,
                 server_socket_addr,
@@ -167,9 +177,13 @@ pub async fn handle_request(
                 cookie_time_values.valid_range,
             )
             .await
+            {
+                Ok(response) => Ok((response, UdpRequestKind::Announce)),
+                Err(err) => Err(err),
+            }
         }
         Request::Scrape(scrape_request) => {
-            handle_scrape(
+            match handle_scrape(
                 &udp_tracker_core_container.scrape_service,
                 client_socket_addr,
                 server_socket_addr,
@@ -178,6 +192,10 @@ pub async fn handle_request(
                 cookie_time_values.valid_range,
             )
             .await
+            {
+                Ok(response) => Ok((response, UdpRequestKind::Scrape)),
+                Err(err) => Err(err),
+            }
         }
     }
 }

packages/udp-tracker-server/src/handlers/scrape.rs

@@ -29,7 +29,7 @@ pub async fn handle_scrape(
     request: &ScrapeRequest,
     opt_udp_server_stats_event_sender: &Arc<Option<Box<dyn server_statistics::event::sender::Sender>>>,
     cookie_valid_range: Range<f64>,
-) -> Result<Response, (Error, TransactionId)> {
+) -> Result<Response, (Error, TransactionId, UdpRequestKind)> {
     tracing::Span::current()
         .record("transaction_id", request.transaction_id.0.to_string())
         .record("connection_id", request.connection_id.0.to_string());
@@ -48,7 +48,7 @@ pub async fn handle_scrape(
     let scrape_data = scrape_service
         .handle_scrape(client_socket_addr, server_socket_addr, request, cookie_valid_range)
         .await
-        .map_err(|e| (e.into(), request.transaction_id))?;
+        .map_err(|e| (e.into(), request.transaction_id, UdpRequestKind::Scrape))?;
 
     Ok(build_response(request, &scrape_data))
 }

packages/udp-tracker-server/src/server/processor.rs

@@ -12,7 +12,7 @@ use tracing::{instrument, Level};
 use super::bound_socket::BoundSocket;
 use crate::container::UdpTrackerServerContainer;
 use crate::handlers::CookieTimeValues;
-use crate::statistics::event::ConnectionContext;
+use crate::statistics::event::{ConnectionContext, UdpRequestKind};
 use crate::{handlers, statistics, RawRequest};
 
 pub struct Processor {
@@ -43,7 +43,7 @@ impl Processor {
 
         let start_time = Instant::now();
 
-        let response = handlers::handle_packet(
+        let (response, opt_req_kind) = handlers::handle_packet(
             request,
             self.udp_tracker_core_container.clone(),
             self.udp_tracker_server_container.clone(),
@@ -54,11 +54,18 @@ impl Processor {
 
         let elapsed_time = start_time.elapsed();
 
-        self.send_response(client_socket_addr, response, elapsed_time).await;
+        self.send_response(client_socket_addr, response, opt_req_kind, elapsed_time)
+            .await;
     }
 
     #[instrument(skip(self))]
-    async fn send_response(self, client_socket_addr: SocketAddr, response: Response, req_processing_time: Duration) {
+    async fn send_response(
+        self,
+        client_socket_addr: SocketAddr,
+        response: Response,
+        opt_req_kind: Option<UdpRequestKind>,
+        req_processing_time: Duration,
+    ) {
         tracing::debug!("send response");
 
         let response_type = match &response {
@@ -79,7 +86,7 @@ impl Processor {
             Response::Scrape(_) => statistics::event::UdpResponseKind::Ok {
                 req_kind: statistics::event::UdpRequestKind::Scrape,
             },
-            Response::Error(_e) => statistics::event::UdpResponseKind::Error,
+            Response::Error(_e) => statistics::event::UdpResponseKind::Error { opt_req_kind: None },
         };
 
         let mut writer = Cursor::new(Vec::with_capacity(200));

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

@@ -80,7 +80,7 @@ pub async fn handle_event(event: Event, stats_repository: &Repository) {
                             .await;
                     }
                 },
-                UdpResponseKind::Error => {}
+                UdpResponseKind::Error { opt_req_kind: _ } => {}
             }
         }
         Event::UdpError { context } => match context.client_socket_addr().ip() {

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

@@ -6,7 +6,7 @@ pub mod listener;
 pub mod sender;
 
 /// An statistics event. It is used to collect tracker metrics.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub enum Event {
     UdpIncomingRequest {
         context: ConnectionContext,
@@ -31,20 +31,27 @@ pub enum Event {
     },
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub enum UdpRequestKind {
     Connect,
     Announce,
     Scrape,
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub enum UdpResponseKind {
-    Ok { req_kind: UdpRequestKind },
-    Error, // todo: add the request kind `{ req_kind: Option(UdpRequestKind) }` when we know it.
+    Ok {
+        req_kind: UdpRequestKind,
+    },
+
+    /// There was an error handling the requests. The error contains the request
+    /// kind if the request was parsed successfully.
+    Error {
+        opt_req_kind: Option<UdpRequestKind>,
+    },
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub struct ConnectionContext {
     client_socket_addr: SocketAddr,
     server_socket_addr: SocketAddr,