refactor: extract tracker api client from tracker service

Author: josecelano

src/app.rs

@@ -44,7 +44,7 @@ pub async fn run(configuration: Configuration) -> Running {
 
     let database = Arc::new(connect_database(&database_connect_url).await.expect("Database error."));
     let auth = Arc::new(AuthorizationService::new(cfg.clone(), database.clone()));
-    let tracker_service = Arc::new(TrackerService::new(cfg.clone(), database.clone()));
+    let tracker_service = Arc::new(TrackerService::new(cfg.clone(), database.clone()).await);
     let mailer_service = Arc::new(MailerService::new(cfg.clone()).await);
     let image_cache_service = Arc::new(ImageCacheService::new(cfg.clone()).await);
 

src/console/commands/import_tracker_statistics.rs

@@ -76,7 +76,7 @@ pub async fn import(_args: &Arguments) {
             .expect("Database error."),
     );
 
-    let tracker_service = Arc::new(TrackerService::new(cfg.clone(), database.clone()));
+    let tracker_service = Arc::new(TrackerService::new(cfg.clone(), database.clone()).await);
 
     tracker_service.update_torrents().await.unwrap();
 }

src/tracker.rs

@@ -1,6 +1,7 @@
 use std::sync::Arc;
 
 use log::{error, info};
+use reqwest::{Error, Response};
 use serde::{Deserialize, Serialize};
 
 use crate::config::Configuration;
@@ -35,148 +36,147 @@ pub struct PeerId {
 }
 
 pub struct TrackerService {
-    cfg: Arc<Configuration>,
     database: Arc<Box<dyn Database>>,
+    api_client: ApiClient,
+    token_valid_seconds: u64,
+    tracker_url: String,
 }
 
 impl TrackerService {
-    pub fn new(cfg: Arc<Configuration>, database: Arc<Box<dyn Database>>) -> TrackerService {
-        TrackerService { cfg, database }
+    pub async fn new(cfg: Arc<Configuration>, database: Arc<Box<dyn Database>>) -> TrackerService {
+        let settings = cfg.settings.read().await;
+        let api_client = ApiClient::new(ApiConnectionInfo::new(
+            settings.tracker.api_url.clone(),
+            settings.tracker.token.clone(),
+        ));
+        let token_valid_seconds = settings.tracker.token_valid_seconds;
+        let tracker_url = settings.tracker.url.clone();
+        drop(settings);
+        TrackerService {
+            database,
+            api_client,
+            token_valid_seconds,
+            tracker_url,
+        }
     }
 
+    /// Add a torrent to the tracker whitelist.
+    ///
+    /// # Errors
+    ///
+    /// Will return an error if the HTTP request failed (for example if the
+    /// tracker API is offline) or if the tracker API returned an error.
     pub async fn whitelist_info_hash(&self, info_hash: String) -> Result<(), ServiceError> {
-        let settings = self.cfg.settings.read().await;
-
-        let request_url = format!(
-            "{}/api/v1/whitelist/{}?token={}",
-            settings.tracker.api_url, info_hash, settings.tracker.token
-        );
-
-        drop(settings);
-
-        let client = reqwest::Client::new();
-
-        let response = client
-            .post(request_url)
-            .send()
-            .await
-            .map_err(|_| ServiceError::TrackerOffline)?;
-
-        if response.status().is_success() {
-            Ok(())
-        } else {
-            Err(ServiceError::WhitelistingError)
+        let response = self.api_client.whitelist_info_hash(&info_hash).await;
+
+        match response {
+            Ok(response) => {
+                if response.status().is_success() {
+                    Ok(())
+                } else {
+                    Err(ServiceError::WhitelistingError)
+                }
+            }
+            Err(_) => Err(ServiceError::TrackerOffline),
         }
     }
 
+    /// Remove a torrent from the tracker whitelist.
+    ///
+    /// # Errors
+    ///
+    /// Will return an error if the HTTP request failed (for example if the
+    /// tracker API is offline) or if the tracker API returned an error.
     pub async fn remove_info_hash_from_whitelist(&self, info_hash: String) -> Result<(), ServiceError> {
-        let settings = self.cfg.settings.read().await;
-
-        let request_url = format!(
-            "{}/api/v1/whitelist/{}?token={}",
-            settings.tracker.api_url, info_hash, settings.tracker.token
-        );
-
-        drop(settings);
-
-        let client = reqwest::Client::new();
-
-        let response = match client.delete(request_url).send().await {
-            Ok(v) => Ok(v),
+        let response = self.api_client.remove_info_hash_from_whitelist(&info_hash).await;
+
+        match response {
+            Ok(response) => {
+                if response.status().is_success() {
+                    Ok(())
+                } else {
+                    Err(ServiceError::InternalServerError)
+                }
+            }
             Err(_) => Err(ServiceError::InternalServerError),
-        }?;
-
-        if response.status().is_success() {
-            return Ok(());
         }
-
-        Err(ServiceError::InternalServerError)
     }
 
-    // get personal tracker announce url of a user
-    // Eg: https://tracker.torrust.com/announce/USER_TRACKER_KEY
+    /// Get personal tracker announce url of a user.
+    ///
+    /// Eg: <https://tracker:7070/USER_TRACKER_KEY>
+    ///
+    /// If the user doesn't have a not expired tracker key, it will generate a
+    /// new one and save it in the database.
+    ///
+    /// # Errors
+    ///
+    /// Will return an error if the HTTP request to get generated a new
+    /// user tracker key failed.
     pub async fn get_personal_announce_url(&self, user_id: i64) -> Result<String, ServiceError> {
-        let settings = self.cfg.settings.read().await;
-
-        // get a valid tracker key for this user from database
         let tracker_key = self.database.get_user_tracker_key(user_id).await;
 
         match tracker_key {
-            Some(v) => Ok(format!("{}/{}", settings.tracker.url, v.key)),
+            Some(v) => Ok(self.announce_url_with_key(&v)),
             None => match self.retrieve_new_tracker_key(user_id).await {
-                Ok(v) => Ok(format!("{}/{}", settings.tracker.url, v.key)),
+                Ok(v) => Ok(self.announce_url_with_key(&v)),
                 Err(_) => Err(ServiceError::TrackerOffline),
             },
         }
     }
 
-    // issue a new tracker key from tracker and save it in database, tied to a user
-    async fn retrieve_new_tracker_key(&self, user_id: i64) -> Result<TrackerKey, ServiceError> {
-        let settings = self.cfg.settings.read().await;
-
-        let request_url = format!(
-            "{}/api/v1/key/{}?token={}",
-            settings.tracker.api_url, settings.tracker.token_valid_seconds, settings.tracker.token
-        );
-
-        drop(settings);
-
-        let client = reqwest::Client::new();
+    /// It builds the announce url appending the user tracker key.
+    /// Eg: <https://tracker:7070/USER_TRACKER_KEY>
+    fn announce_url_with_key(&self, tracker_key: &TrackerKey) -> String {
+        format!("{}/{}", self.tracker_url, tracker_key.key)
+    }
 
-        // issue new tracker key
-        let response = client
-            .post(request_url)
-            .send()
+    /// Issue a new tracker key from tracker and save it in database,
+    /// tied to a user
+    async fn retrieve_new_tracker_key(&self, user_id: i64) -> Result<TrackerKey, ServiceError> {
+        // Request new tracker key from tracker
+        let response = self
+            .api_client
+            .retrieve_new_tracker_key(self.token_valid_seconds)
             .await
             .map_err(|_| ServiceError::InternalServerError)?;
 
-        // get tracker key from response
+        // Parse tracker key from response
         let tracker_key = response
             .json::<TrackerKey>()
             .await
             .map_err(|_| ServiceError::InternalServerError)?;
 
-        // add tracker key to database (tied to a user)
+        // Add tracker key to database (tied to a user)
         self.database.add_tracker_key(user_id, &tracker_key).await?;
 
         // return tracker key
         Ok(tracker_key)
     }
 
-    // get torrent info from tracker api
+    /// Get torrent info from tracker API
+    ///
+    /// # Errors
+    ///
+    /// Will return an error if the HTTP request failed or the torrent is not
+    /// found.
     pub async fn get_torrent_info(&self, torrent_id: i64, info_hash: &str) -> Result<TorrentInfo, ServiceError> {
-        let settings = self.cfg.settings.read().await;
-
-        let tracker_url = settings.tracker.url.clone();
-
-        let request_url = format!(
-            "{}/api/v1/torrent/{}?token={}",
-            settings.tracker.api_url, info_hash, settings.tracker.token
-        );
-
-        drop(settings);
-
-        let client = reqwest::Client::new();
-        let response = match client.get(request_url).send().await {
-            Ok(v) => Ok(v),
-            Err(_) => Err(ServiceError::InternalServerError),
-        }?;
-
-        let torrent_info = match response.json::<TorrentInfo>().await {
-            Ok(torrent_info) => {
-                let _ = self
-                    .database
-                    .update_tracker_info(torrent_id, &tracker_url, torrent_info.seeders, torrent_info.leechers)
-                    .await;
-                Ok(torrent_info)
-            }
-            Err(_) => {
-                let _ = self.database.update_tracker_info(torrent_id, &tracker_url, 0, 0).await;
-                Err(ServiceError::TorrentNotFound)
-            }
-        }?;
+        let response = self
+            .api_client
+            .get_torrent_info(info_hash)
+            .await
+            .map_err(|_| ServiceError::InternalServerError)?;
 
-        Ok(torrent_info)
+        if let Ok(torrent_info) = response.json::<TorrentInfo>().await {
+            let _ = self
+                .database
+                .update_tracker_info(torrent_id, &self.tracker_url, torrent_info.seeders, torrent_info.leechers)
+                .await;
+            Ok(torrent_info)
+        } else {
+            let _ = self.database.update_tracker_info(torrent_id, &self.tracker_url, 0, 0).await;
+            Err(ServiceError::TorrentNotFound)
+        }
     }
 
     pub async fn update_torrents(&self) -> Result<(), ServiceError> {
@@ -203,3 +203,70 @@ impl TrackerService {
         self.get_torrent_info(torrent_id, info_hash).await
     }
 }
+
+struct ApiConnectionInfo {
+    pub url: String,
+    pub token: String,
+}
+
+impl ApiConnectionInfo {
+    pub fn new(url: String, token: String) -> Self {
+        Self { url, token }
+    }
+}
+
+struct ApiClient {
+    pub connection_info: ApiConnectionInfo,
+    base_url: String,
+}
+
+impl ApiClient {
+    pub fn new(connection_info: ApiConnectionInfo) -> Self {
+        let base_url = format!("{}/api/v1", connection_info.url);
+        Self {
+            connection_info,
+            base_url,
+        }
+    }
+
+    pub async fn whitelist_info_hash(&self, info_hash: &str) -> Result<Response, Error> {
+        let request_url = format!(
+            "{}/whitelist/{}?token={}",
+            self.base_url, info_hash, self.connection_info.token
+        );
+
+        let client = reqwest::Client::new();
+
+        client.post(request_url).send().await
+    }
+
+    pub async fn remove_info_hash_from_whitelist(&self, info_hash: &str) -> Result<Response, Error> {
+        let request_url = format!(
+            "{}/whitelist/{}?token={}",
+            self.base_url, info_hash, self.connection_info.token
+        );
+
+        let client = reqwest::Client::new();
+
+        client.delete(request_url).send().await
+    }
+
+    async fn retrieve_new_tracker_key(&self, token_valid_seconds: u64) -> Result<Response, Error> {
+        let request_url = format!(
+            "{}/key/{}?token={}",
+            self.base_url, token_valid_seconds, self.connection_info.token
+        );
+
+        let client = reqwest::Client::new();
+
+        client.post(request_url).send().await
+    }
+
+    pub async fn get_torrent_info(&self, info_hash: &str) -> Result<Response, Error> {
+        let request_url = format!("{}/torrent/{}?token={}", self.base_url, info_hash, self.connection_info.token);
+
+        let client = reqwest::Client::new();
+
+        client.get(request_url).send().await
+    }
+}