refactor: [torrust#1524] move total downloads udpate from announce command to event handler

Author: josecelano

packages/tracker-core/src/announce_handler.rs

@@ -163,6 +163,11 @@ impl AnnounceHandler {
     ) -> Result<AnnounceData, AnnounceError> {
         self.whitelist_authorization.authorize(info_hash).await?;
 
+        // This will be removed in the future.
+        // See https://github.com/torrust/torrust-tracker/issues/1502
+        // There will be a persisted metric for counting the total number of
+        // downloads across all torrents. The in-memory metric will count only
+        // the number of downloads during the current tracker uptime.
         let opt_persistent_torrent = if self.config.tracker_policy.persistent_torrent_completed_stat {
             self.db_torrent_repository.load(info_hash)?
         } else {
@@ -171,15 +176,11 @@ impl AnnounceHandler {
 
         peer.change_ip(&assign_ip_address_to_peer(remote_client_ip, self.config.net.external_ip));
 
-        let number_of_downloads_increased = self
+        let _number_of_downloads_increased = self
             .in_memory_torrent_repository
             .upsert_peer(info_hash, peer, opt_persistent_torrent)
             .await;
 
-        if self.config.tracker_policy.persistent_torrent_completed_stat && number_of_downloads_increased {
-            self.db_torrent_repository.increase_number_of_downloads(info_hash)?;
-        }
-
         Ok(self.build_announce_data(info_hash, peer, peers_wanted).await)
     }
 

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

@@ -1,7 +1,15 @@
+use std::sync::Arc;
+
 use torrust_tracker_primitives::DurationSinceUnixEpoch;
 use torrust_tracker_torrent_repository::event::Event;
 
-pub async fn handle_event(event: Event, _now: DurationSinceUnixEpoch) {
+use crate::torrent::repository::persisted::DatabasePersistentTorrentRepository;
+
+pub async fn handle_event(
+    event: Event,
+    db_torrent_repository: &Arc<DatabasePersistentTorrentRepository>,
+    _now: DurationSinceUnixEpoch,
+) {
     match event {
         // Torrent events
         Event::TorrentAdded { info_hash, .. } => {
@@ -27,6 +35,15 @@ pub async fn handle_event(event: Event, _now: DurationSinceUnixEpoch) {
         }
         Event::PeerDownloadCompleted { info_hash, peer } => {
             tracing::debug!(info_hash = ?info_hash, peer = ?peer, "Peer download completed", );
+
+            match db_torrent_repository.increase_number_of_downloads(&info_hash) {
+                Ok(()) => {
+                    tracing::debug!(info_hash = ?info_hash, "Number of downloads increased");
+                }
+                Err(err) => {
+                    tracing::error!(info_hash = ?info_hash, error = ?err, "Failed to increase number of downloads");
+                }
+            }
         }
     }
 }

packages/tracker-core/src/statistics/event/listener.rs

@@ -1,23 +1,31 @@
+use std::sync::Arc;
+
 use tokio::task::JoinHandle;
 use torrust_tracker_clock::clock::Time;
 use torrust_tracker_events::receiver::RecvError;
 use torrust_tracker_torrent_repository::event::receiver::Receiver;
 
 use super::handler::handle_event;
+use crate::torrent::repository::persisted::DatabasePersistentTorrentRepository;
 use crate::{CurrentClock, TRACKER_CORE_LOG_TARGET};
 
 #[must_use]
-pub fn run_event_listener(receiver: Receiver) -> JoinHandle<()> {
+pub fn run_event_listener(
+    receiver: Receiver,
+    db_torrent_repository: &Arc<DatabasePersistentTorrentRepository>,
+) -> JoinHandle<()> {
+    let db_torrent_repository: Arc<DatabasePersistentTorrentRepository> = db_torrent_repository.clone();
+
     tracing::info!(target: TRACKER_CORE_LOG_TARGET, "Starting torrent repository event listener");
 
     tokio::spawn(async move {
-        dispatch_events(receiver).await;
+        dispatch_events(receiver, db_torrent_repository).await;
 
         tracing::info!(target: TRACKER_CORE_LOG_TARGET, "Torrent repository listener finished");
     })
 }
 
-async fn dispatch_events(mut receiver: Receiver) {
+async fn dispatch_events(mut receiver: Receiver, db_torrent_repository: Arc<DatabasePersistentTorrentRepository>) {
     let shutdown_signal = tokio::signal::ctrl_c();
 
     tokio::pin!(shutdown_signal);
@@ -33,7 +41,7 @@ async fn dispatch_events(mut receiver: Receiver) {
 
             result = receiver.recv() => {
                 match result {
-                    Ok(event) => handle_event(event, CurrentClock::now()).await,
+                    Ok(event) => handle_event(event, &db_torrent_repository, CurrentClock::now()).await,
                     Err(e) => {
                         match e {
                             RecvError::Closed => {

src/bootstrap/jobs/tracker_core.rs

@@ -11,6 +11,7 @@ pub fn start_event_listener(config: &Configuration, app_container: &Arc<AppConta
     if config.core.tracker_policy.persistent_torrent_completed_stat {
         let job = bittorrent_tracker_core::statistics::event::listener::run_event_listener(
             app_container.torrent_repository_container.event_bus.receiver(),
+            &app_container.tracker_core_container.db_torrent_repository,
         );
 
         Some(job)