feat: [torrust#1145] add banned ips total for UDP to stats

```json
{
  "torrents": 0,
  "seeders": 0,
  "completed": 0,
  "leechers": 0,
  "tcp4_connections_handled": 0,
  "tcp4_announces_handled": 0,
  "tcp4_scrapes_handled": 0,
  "tcp6_connections_handled": 0,
  "tcp6_announces_handled": 0,
  "tcp6_scrapes_handled": 0,
  "udp_requests_aborted": 0,
  "udp_requests_banned": 0,
  "udp_banned_ips_total": 0,
  "udp4_requests": 0,
  "udp4_connections_handled": 0,
  "udp4_announces_handled": 0,
  "udp4_scrapes_handled": 0,
  "udp4_responses": 0,
  "udp4_errors_handled": 0,
  "udp6_requests": 0,
  "udp6_connections_handled": 0,
  "udp6_announces_handled": 0,
  "udp6_scrapes_handled": 0,
  "udp6_responses": 0,
  "udp6_errors_handled": 0
}
```

The new metric: `udp_banned_ips_total`. It's the total number of IPs that have been banned for sending wrong connection IDs.

Author: josecelano

src/app.rs

@@ -113,6 +113,7 @@ pub async fn start(
         if let Some(job) = tracker_apis::start_job(
             http_api_config,
             tracker.clone(),
+            ban_service.clone(),
             registar.give_form(),
             servers::apis::Version::V1,
         )

src/bootstrap/app.rs

@@ -47,11 +47,11 @@ pub fn setup() -> (Configuration, Arc<Tracker>, Arc<RwLock<BanService>>) {
 
     let tracker = initialize_with_configuration(&configuration);
 
-    let ban_service = Arc::new(RwLock::new(BanService::new(MAX_CONNECTION_ID_ERRORS_PER_IP)));
+    let udp_ban_service = Arc::new(RwLock::new(BanService::new(MAX_CONNECTION_ID_ERRORS_PER_IP)));
 
     tracing::info!("Configuration:\n{}", configuration.clone().mask_secrets().to_json());
 
-    (configuration, tracker, ban_service)
+    (configuration, tracker, udp_ban_service)
 }
 
 /// checks if the seed is the instance seed in production.

src/bootstrap/jobs/tracker_apis.rs

@@ -24,6 +24,7 @@ use std::net::SocketAddr;
 use std::sync::Arc;
 
 use axum_server::tls_rustls::RustlsConfig;
+use tokio::sync::RwLock;
 use tokio::task::JoinHandle;
 use torrust_tracker_configuration::{AccessTokens, HttpApi};
 use tracing::instrument;
@@ -33,6 +34,7 @@ use crate::core;
 use crate::servers::apis::server::{ApiServer, Launcher};
 use crate::servers::apis::Version;
 use crate::servers::registar::ServiceRegistrationForm;
+use crate::servers::udp::server::banning::BanService;
 
 /// This is the message that the "launcher" spawned task sends to the main
 /// application process to notify the API server was successfully started.
@@ -54,10 +56,11 @@ pub struct ApiServerJobStarted();
 /// It would panic if unable to send the  `ApiServerJobStarted` notice.
 ///
 ///
-#[instrument(skip(config, tracker, form))]
+#[instrument(skip(config, tracker, ban_service, form))]
 pub async fn start_job(
     config: &HttpApi,
     tracker: Arc<core::Tracker>,
+    ban_service: Arc<RwLock<BanService>>,
     form: ServiceRegistrationForm,
     version: Version,
 ) -> Option<JoinHandle<()>> {
@@ -70,21 +73,22 @@ pub async fn start_job(
     let access_tokens = Arc::new(config.access_tokens.clone());
 
     match version {
-        Version::V1 => Some(start_v1(bind_to, tls, tracker.clone(), form, access_tokens).await),
+        Version::V1 => Some(start_v1(bind_to, tls, tracker.clone(), ban_service.clone(), form, access_tokens).await),
     }
 }
 
 #[allow(clippy::async_yields_async)]
-#[instrument(skip(socket, tls, tracker, form, access_tokens))]
+#[instrument(skip(socket, tls, tracker, ban_service, form, access_tokens))]
 async fn start_v1(
     socket: SocketAddr,
     tls: Option<RustlsConfig>,
     tracker: Arc<core::Tracker>,
+    ban_service: Arc<RwLock<BanService>>,
     form: ServiceRegistrationForm,
     access_tokens: Arc<AccessTokens>,
 ) -> JoinHandle<()> {
     let server = ApiServer::new(Launcher::new(socket, tls))
-        .start(tracker, form, access_tokens)
+        .start(tracker, ban_service, form, access_tokens)
         .await
         .expect("it should be able to start to the tracker api");
 
@@ -98,21 +102,25 @@ async fn start_v1(
 mod tests {
     use std::sync::Arc;
 
+    use tokio::sync::RwLock;
     use torrust_tracker_test_helpers::configuration::ephemeral_public;
 
     use crate::bootstrap::app::initialize_with_configuration;
     use crate::bootstrap::jobs::tracker_apis::start_job;
     use crate::servers::apis::Version;
     use crate::servers::registar::Registar;
+    use crate::servers::udp::server::banning::BanService;
+    use crate::servers::udp::server::launcher::MAX_CONNECTION_ID_ERRORS_PER_IP;
 
     #[tokio::test]
     async fn it_should_start_http_tracker() {
         let cfg = Arc::new(ephemeral_public());
         let config = &cfg.http_api.clone().unwrap();
         let tracker = initialize_with_configuration(&cfg);
+        let ban_service = Arc::new(RwLock::new(BanService::new(MAX_CONNECTION_ID_ERRORS_PER_IP)));
         let version = Version::V1;
 
-        start_job(config, tracker, Registar::default().give_form(), version)
+        start_job(config, tracker, ban_service, Registar::default().give_form(), version)
             .await
             .expect("it should be able to join to the tracker api start-job");
     }

src/core/services/statistics/mod.rs

@@ -40,10 +40,12 @@ pub mod setup;
 
 use std::sync::Arc;
 
+use tokio::sync::RwLock;
 use torrust_tracker_primitives::torrent_metrics::TorrentsMetrics;
 
 use crate::core::statistics::metrics::Metrics;
 use crate::core::Tracker;
+use crate::servers::udp::server::banning::BanService;
 
 /// All the metrics collected by the tracker.
 #[derive(Debug, PartialEq)]
@@ -60,9 +62,10 @@ pub struct TrackerMetrics {
 }
 
 /// It returns all the [`TrackerMetrics`]
-pub async fn get_metrics(tracker: Arc<Tracker>) -> TrackerMetrics {
+pub async fn get_metrics(tracker: Arc<Tracker>, ban_service: Arc<RwLock<BanService>>) -> TrackerMetrics {
     let torrents_metrics = tracker.get_torrents_metrics();
     let stats = tracker.get_stats().await;
+    let udp_banned_ips_total = ban_service.read().await.get_banned_ips_total();
 
     TrackerMetrics {
         torrents_metrics,
@@ -77,6 +80,7 @@ pub async fn get_metrics(tracker: Arc<Tracker>) -> TrackerMetrics {
             // UDP
             udp_requests_aborted: stats.udp_requests_aborted,
             udp_requests_banned: stats.udp_requests_banned,
+            udp_banned_ips_total: udp_banned_ips_total as u64,
             udp4_requests: stats.udp4_requests,
             udp4_connections_handled: stats.udp4_connections_handled,
             udp4_announces_handled: stats.udp4_announces_handled,
@@ -97,13 +101,16 @@ pub async fn get_metrics(tracker: Arc<Tracker>) -> TrackerMetrics {
 mod tests {
     use std::sync::Arc;
 
+    use tokio::sync::RwLock;
     use torrust_tracker_configuration::Configuration;
     use torrust_tracker_primitives::torrent_metrics::TorrentsMetrics;
     use torrust_tracker_test_helpers::configuration;
 
     use crate::core;
     use crate::core::services::statistics::{get_metrics, TrackerMetrics};
     use crate::core::services::tracker_factory;
+    use crate::servers::udp::server::banning::BanService;
+    use crate::servers::udp::server::launcher::MAX_CONNECTION_ID_ERRORS_PER_IP;
 
     pub fn tracker_configuration() -> Configuration {
         configuration::ephemeral()
@@ -112,8 +119,9 @@ mod tests {
     #[tokio::test]
     async fn the_statistics_service_should_return_the_tracker_metrics() {
         let tracker = Arc::new(tracker_factory(&tracker_configuration()));
+        let ban_service = Arc::new(RwLock::new(BanService::new(MAX_CONNECTION_ID_ERRORS_PER_IP)));
 
-        let tracker_metrics = get_metrics(tracker.clone()).await;
+        let tracker_metrics = get_metrics(tracker.clone(), ban_service.clone()).await;
 
         assert_eq!(
             tracker_metrics,

src/core/statistics/metrics.rs

@@ -34,6 +34,9 @@ pub struct Metrics {
     /// Total number of UDP (UDP tracker) requests banned.
     pub udp_requests_banned: u64,
 
+    /// Total number of banned IPs.
+    pub udp_banned_ips_total: u64,
+
     /// Total number of UDP (UDP tracker) requests from IPv4 peers.
     pub udp4_requests: u64,
 

src/main.rs

@@ -2,9 +2,9 @@ use torrust_tracker_lib::{app, bootstrap};
 
 #[tokio::main]
 async fn main() {
-    let (config, tracker, ban_service) = bootstrap::app::setup();
+    let (config, tracker, udp_ban_service) = bootstrap::app::setup();
 
-    let jobs = app::start(&config, tracker, ban_service).await;
+    let jobs = app::start(&config, tracker, udp_ban_service).await;
 
     // handle the signals
     tokio::select! {

src/servers/apis/routes.rs

@@ -15,6 +15,7 @@ use axum::response::Response;
 use axum::routing::get;
 use axum::{middleware, BoxError, Router};
 use hyper::{Request, StatusCode};
+use tokio::sync::RwLock;
 use torrust_tracker_configuration::{AccessTokens, DEFAULT_TIMEOUT};
 use tower::timeout::TimeoutLayer;
 use tower::ServiceBuilder;
@@ -32,16 +33,22 @@ use super::v1::middlewares::auth::State;
 use crate::core::Tracker;
 use crate::servers::apis::API_LOG_TARGET;
 use crate::servers::logging::Latency;
+use crate::servers::udp::server::banning::BanService;
 
 /// Add all API routes to the router.
 #[allow(clippy::needless_pass_by_value)]
-#[instrument(skip(tracker, access_tokens))]
-pub fn router(tracker: Arc<Tracker>, access_tokens: Arc<AccessTokens>, server_socket_addr: SocketAddr) -> Router {
+#[instrument(skip(tracker, ban_service, access_tokens))]
+pub fn router(
+    tracker: Arc<Tracker>,
+    ban_service: Arc<RwLock<BanService>>,
+    access_tokens: Arc<AccessTokens>,
+    server_socket_addr: SocketAddr,
+) -> Router {
     let router = Router::new();
 
     let api_url_prefix = "/api";
 
-    let router = v1::routes::add(api_url_prefix, router, tracker.clone());
+    let router = v1::routes::add(api_url_prefix, router, tracker.clone(), ban_service.clone());
 
     let state = State { access_tokens };
 

src/servers/apis/server.rs

@@ -33,6 +33,7 @@ use derive_more::Constructor;
 use futures::future::BoxFuture;
 use thiserror::Error;
 use tokio::sync::oneshot::{Receiver, Sender};
+use tokio::sync::RwLock;
 use torrust_tracker_configuration::AccessTokens;
 use tracing::{instrument, Level};
 
@@ -44,6 +45,7 @@ use crate::servers::custom_axum_server::{self, TimeoutAcceptor};
 use crate::servers::logging::STARTED_ON;
 use crate::servers::registar::{ServiceHealthCheckJob, ServiceRegistration, ServiceRegistrationForm};
 use crate::servers::signals::{graceful_shutdown, Halted};
+use crate::servers::udp::server::banning::BanService;
 
 /// Errors that can occur when starting or stopping the API server.
 #[derive(Debug, Error)]
@@ -122,10 +124,11 @@ impl ApiServer<Stopped> {
     /// # Panics
     ///
     /// It would panic if the bound socket address cannot be sent back to this starter.
-    #[instrument(skip(self, tracker, form, access_tokens), err, ret(Display, level = Level::INFO))]
+    #[instrument(skip(self, tracker, ban_service, form, access_tokens), err, ret(Display, level = Level::INFO))]
     pub async fn start(
         self,
         tracker: Arc<Tracker>,
+        ban_service: Arc<RwLock<BanService>>,
         form: ServiceRegistrationForm,
         access_tokens: Arc<AccessTokens>,
     ) -> Result<ApiServer<Running>, Error> {
@@ -137,7 +140,7 @@ impl ApiServer<Stopped> {
         let task = tokio::spawn(async move {
             tracing::debug!(target: API_LOG_TARGET, "Starting with launcher in spawned task ...");
 
-            let _task = launcher.start(tracker, access_tokens, tx_start, rx_halt).await;
+            let _task = launcher.start(tracker, ban_service, access_tokens, tx_start, rx_halt).await;
 
             tracing::debug!(target: API_LOG_TARGET, "Started with launcher in spawned task");
 
@@ -235,18 +238,19 @@ impl Launcher {
     ///
     /// Will panic if unable to bind to the socket, or unable to get the address of the bound socket.
     /// Will also panic if unable to send message regarding the bound socket address.
-    #[instrument(skip(self, tracker, access_tokens, tx_start, rx_halt))]
+    #[instrument(skip(self, tracker, ban_service, access_tokens, tx_start, rx_halt))]
     pub fn start(
         &self,
         tracker: Arc<Tracker>,
+        ban_service: Arc<RwLock<BanService>>,
         access_tokens: Arc<AccessTokens>,
         tx_start: Sender<Started>,
         rx_halt: Receiver<Halted>,
     ) -> BoxFuture<'static, ()> {
         let socket = std::net::TcpListener::bind(self.bind_to).expect("Could not bind tcp_listener to address.");
         let address = socket.local_addr().expect("Could not get local_addr from tcp_listener.");
 
-        let router = router(tracker, access_tokens, address);
+        let router = router(tracker, ban_service, access_tokens, address);
 
         let handle = Handle::new();
 
@@ -294,19 +298,23 @@ impl Launcher {
 mod tests {
     use std::sync::Arc;
 
+    use tokio::sync::RwLock;
     use torrust_tracker_test_helpers::configuration::ephemeral_public;
 
     use crate::bootstrap::app::initialize_with_configuration;
     use crate::bootstrap::jobs::make_rust_tls;
     use crate::servers::apis::server::{ApiServer, Launcher};
     use crate::servers::registar::Registar;
+    use crate::servers::udp::server::banning::BanService;
+    use crate::servers::udp::server::launcher::MAX_CONNECTION_ID_ERRORS_PER_IP;
 
     #[tokio::test]
     async fn it_should_be_able_to_start_and_stop() {
         let cfg = Arc::new(ephemeral_public());
         let config = &cfg.http_api.clone().unwrap();
 
         let tracker = initialize_with_configuration(&cfg);
+        let ban_service = Arc::new(RwLock::new(BanService::new(MAX_CONNECTION_ID_ERRORS_PER_IP)));
 
         let bind_to = config.bind_address;
 
@@ -321,7 +329,7 @@ mod tests {
         let register = &Registar::default();
 
         let started = stopped
-            .start(tracker, register.give_form(), access_tokens)
+            .start(tracker, ban_service, register.give_form(), access_tokens)
             .await
             .expect("it should start the server");
         let stopped = started.stop().await.expect("it should stop the server");

src/servers/apis/v1/context/stats/handlers.rs

@@ -6,10 +6,12 @@ use axum::extract::State;
 use axum::response::Response;
 use axum_extra::extract::Query;
 use serde::Deserialize;
+use tokio::sync::RwLock;
 
 use super::responses::{metrics_response, stats_response};
 use crate::core::services::statistics::get_metrics;
 use crate::core::Tracker;
+use crate::servers::udp::server::banning::BanService;
 
 #[derive(Deserialize, Debug, Default)]
 #[serde(rename_all = "lowercase")]
@@ -35,8 +37,11 @@ pub struct QueryParams {
 ///
 /// Refer to the [API endpoint documentation](crate::servers::apis::v1::context::stats#get-tracker-statistics)
 /// for more information about this endpoint.
-pub async fn get_stats_handler(State(tracker): State<Arc<Tracker>>, params: Query<QueryParams>) -> Response {
-    let metrics = get_metrics(tracker.clone()).await;
+pub async fn get_stats_handler(
+    State(state): State<(Arc<Tracker>, Arc<RwLock<BanService>>)>,
+    params: Query<QueryParams>,
+) -> Response {
+    let metrics = get_metrics(state.0.clone(), state.1.clone()).await;
 
     match params.0.format {
         Some(format) => match format {