Merge torrust#1202: Overhaul core Tracker: extract torrents context (part 1)

612f729 refactor: [torrust#1201] remove tracker dependency on TorrentsManager (Jose Celano)
3a2e8f0 refactor: [torrust#1201] reorganize methods in tracker (Jose Celano)
b3fcdb4 refactor: [torrust#1201] remove direct dependency on database from tracker (Jose Celano)
bdc3f22 refactor: [torrust#1201] add database to app container y environments (Jose Celano)
a4a2d67 refactor: [torrust#1201] remove pub fn from tracker (Jose Celano)
6fb632e refactor: [torrust#1201] remove duplicate code (Jose Celano)
4e3dbae refactor: [torrust#1201] inject new extracted sercvies in core tracker (Jose Celano)
6332261 refactor: [torrust#1201] extract TorrentsManager (Jose Celano)
f4dcb51 refactor: [torrust#1201] rename tracker field (Jose Celano)
9b5f776 refactor: [torrust#1201] exatrct DatabasePersistentTorrentRepository (Jose Celano)
03ef7f6 refactor: [1201] extract InMemoryTorrentRepository (Jose Celano)

Pull request description:

  Overhaul core Tracker: extract torrents context.

  This PR is part of the implementation of the issue: torrust#1201.

  The core Tracker is getting smaller and smaller. This PR reduces the dependencies to:

  ```rust
  pub struct Tracker {
      /// The tracker configuration.
      config: Core,

      /// The service to check is a torrent is whitelisted.
      pub whitelist_authorization: Arc<whitelist::authorization::Authorization>,

      /// The in-memory torrents repository.
      in_memory_torrent_repository: Arc<InMemoryTorrentRepository>,

      /// The persistent torrents repository.
      db_torrent_repository: Arc<DatabasePersistentTorrentRepository>,
  }
  ```

  I will open a new PR (part 2) to continue extracting the rest of methods that are not used directly in a `announce` or `scrape` requests.

ACKs for top commit:
  josecelano:
    ACK 612f729

Tree-SHA512: 3ac17b515e9c521c128cd3694724d9f5294a1ea8a0b123959953d48d20556efec1de8e105c297bf1e75d1164b91fe4805c970a223572edc8ece9de2d020ce7d6

Author: josecelano

src/app.rs

@@ -137,7 +137,7 @@ pub async fn start(config: &Configuration, app_container: &AppContainer) -> Vec<
 
     // Start runners to remove torrents without peers, every interval
     if config.core.inactive_peer_cleanup_interval > 0 {
-        jobs.push(torrent_cleanup::start_job(&config.core, &app_container.tracker));
+        jobs.push(torrent_cleanup::start_job(&config.core, &app_container.torrents_manager));
     }
 
     // Start Health Check API

src/app_test.rs

@@ -9,6 +9,9 @@ use crate::core::authentication::key::repository::persisted::DatabaseKeyReposito
 use crate::core::authentication::service::{self, AuthenticationService};
 use crate::core::databases::Database;
 use crate::core::services::initialize_database;
+use crate::core::torrent::manager::TorrentsManager;
+use crate::core::torrent::repository::in_memory::InMemoryTorrentRepository;
+use crate::core::torrent::repository::persisted::DatabasePersistentTorrentRepository;
 use crate::core::whitelist;
 use crate::core::whitelist::repository::in_memory::InMemoryWhitelist;
 
@@ -22,6 +25,9 @@ pub fn initialize_tracker_dependencies(
     Arc<InMemoryWhitelist>,
     Arc<whitelist::authorization::Authorization>,
     Arc<AuthenticationService>,
+    Arc<InMemoryTorrentRepository>,
+    Arc<DatabasePersistentTorrentRepository>,
+    Arc<TorrentsManager>,
 ) {
     let database = initialize_database(config);
     let in_memory_whitelist = Arc::new(InMemoryWhitelist::default());
@@ -36,6 +42,21 @@ pub fn initialize_tracker_dependencies(
         &db_key_repository.clone(),
         &in_memory_key_repository.clone(),
     ));
+    let in_memory_torrent_repository = Arc::new(InMemoryTorrentRepository::default());
+    let db_torrent_repository = Arc::new(DatabasePersistentTorrentRepository::new(&database));
+    let torrents_manager = Arc::new(TorrentsManager::new(
+        &config.core,
+        &in_memory_torrent_repository,
+        &db_torrent_repository,
+    ));
 
-    (database, in_memory_whitelist, whitelist_authorization, authentication_service)
+    (
+        database,
+        in_memory_whitelist,
+        whitelist_authorization,
+        authentication_service,
+        in_memory_torrent_repository,
+        db_torrent_repository,
+        torrents_manager,
+    )
 }

src/bootstrap/app.rs

@@ -27,6 +27,9 @@ use crate::core::authentication::key::repository::in_memory::InMemoryKeyReposito
 use crate::core::authentication::key::repository::persisted::DatabaseKeyRepository;
 use crate::core::authentication::service;
 use crate::core::services::{initialize_database, initialize_tracker, initialize_whitelist_manager, statistics};
+use crate::core::torrent::manager::TorrentsManager;
+use crate::core::torrent::repository::in_memory::InMemoryTorrentRepository;
+use crate::core::torrent::repository::persisted::DatabasePersistentTorrentRepository;
 use crate::core::whitelist;
 use crate::core::whitelist::repository::in_memory::InMemoryWhitelist;
 use crate::servers::udp::server::banning::BanService;
@@ -103,10 +106,23 @@ pub fn initialize_app_container(configuration: &Configuration) -> AppContainer {
         &db_key_repository.clone(),
         &in_memory_key_repository.clone(),
     ));
+    let in_memory_torrent_repository = Arc::new(InMemoryTorrentRepository::default());
+    let db_torrent_repository = Arc::new(DatabasePersistentTorrentRepository::new(&database));
+    let torrents_manager = Arc::new(TorrentsManager::new(
+        &configuration.core,
+        &in_memory_torrent_repository,
+        &db_torrent_repository,
+    ));
 
-    let tracker = Arc::new(initialize_tracker(configuration, &database, &whitelist_authorization));
+    let tracker = Arc::new(initialize_tracker(
+        configuration,
+        &whitelist_authorization,
+        &in_memory_torrent_repository,
+        &db_torrent_repository,
+    ));
 
     AppContainer {
+        database,
         tracker,
         keys_handler,
         authentication_service,
@@ -115,6 +131,9 @@ pub fn initialize_app_container(configuration: &Configuration) -> AppContainer {
         stats_event_sender,
         stats_repository,
         whitelist_manager,
+        in_memory_torrent_repository,
+        db_torrent_repository,
+        torrents_manager,
     }
 }
 

src/bootstrap/jobs/torrent_cleanup.rs

@@ -17,17 +17,17 @@ use tokio::task::JoinHandle;
 use torrust_tracker_configuration::Core;
 use tracing::instrument;
 
-use crate::core;
+use crate::core::torrent::manager::TorrentsManager;
 
 /// It starts a jobs for cleaning up the torrent data in the tracker.
 ///
 /// The cleaning task is executed on an `inactive_peer_cleanup_interval`.
 ///
 /// Refer to [`torrust-tracker-configuration documentation`](https://docs.rs/torrust-tracker-configuration) for more info about that option.
 #[must_use]
-#[instrument(skip(config, tracker))]
-pub fn start_job(config: &Core, tracker: &Arc<core::Tracker>) -> JoinHandle<()> {
-    let weak_tracker = std::sync::Arc::downgrade(tracker);
+#[instrument(skip(config, torrents_manager))]
+pub fn start_job(config: &Core, torrents_manager: &Arc<TorrentsManager>) -> JoinHandle<()> {
+    let weak_torrents_manager = std::sync::Arc::downgrade(torrents_manager);
     let interval = config.inactive_peer_cleanup_interval;
 
     tokio::spawn(async move {
@@ -42,10 +42,10 @@ pub fn start_job(config: &Core, tracker: &Arc<core::Tracker>) -> JoinHandle<()>
                     break;
                 }
                 _ = interval.tick() => {
-                    if let Some(tracker) = weak_tracker.upgrade() {
+                    if let Some(torrents_manager) = weak_torrents_manager.upgrade() {
                         let start_time = Utc::now().time();
                         tracing::info!("Cleaning up torrents..");
-                        tracker.cleanup_torrents();
+                        torrents_manager.cleanup_torrents();
                         tracing::info!("Cleaned up torrents in: {}ms", (Utc::now().time() - start_time).num_milliseconds());
                     } else {
                         break;

src/container.rs

@@ -4,13 +4,18 @@ use tokio::sync::RwLock;
 
 use crate::core::authentication::handler::KeysHandler;
 use crate::core::authentication::service::AuthenticationService;
+use crate::core::databases::Database;
 use crate::core::statistics::event::sender::Sender;
 use crate::core::statistics::repository::Repository;
+use crate::core::torrent::manager::TorrentsManager;
+use crate::core::torrent::repository::in_memory::InMemoryTorrentRepository;
+use crate::core::torrent::repository::persisted::DatabasePersistentTorrentRepository;
 use crate::core::whitelist::manager::WhiteListManager;
 use crate::core::{whitelist, Tracker};
 use crate::servers::udp::server::banning::BanService;
 
 pub struct AppContainer {
+    pub database: Arc<Box<dyn Database>>,
     pub tracker: Arc<Tracker>,
     pub keys_handler: Arc<KeysHandler>,
     pub authentication_service: Arc<AuthenticationService>,
@@ -19,4 +24,7 @@ pub struct AppContainer {
     pub stats_event_sender: Arc<Option<Box<dyn Sender>>>,
     pub stats_repository: Arc<Repository>,
     pub whitelist_manager: Arc<WhiteListManager>,
+    pub in_memory_torrent_repository: Arc<InMemoryTorrentRepository>,
+    pub db_torrent_repository: Arc<DatabasePersistentTorrentRepository>,
+    pub torrents_manager: Arc<TorrentsManager>,
 }