Extract Tracker API Client packages

[josecelano]

Relates to: torrust/torrust-index#806
Relates to: #255 (comment)

We are using a Tracker API Client in test code.

See: https://github.com/torrust/torrust-tracker/blob/develop/tests/servers/api/v1/client.rs

That client is duplicated in the Index because the Index calls the Tracker API:

https://github.com/torrust/torrust-index/blob/develop/src/tracker/api.rs

We should extract that login into an independent package so that the Index can use it and we remove that duplicate code.

Before extracting the package we should clean it and make it ready for production. Currently, is not ready because

• The URL schema is hardcoded to http://.
• It panics if the HTTP fails. We should return an error and let the user handle it.
• We should decide if we expose request errors or we wrap them.

I propose to create this packages:

• folder (crates.io package name)
• packages/api-types (torrust-tracker-api-types)
• packages/api-client (torrust-tracker-api-client) <- depends on torrust-tracker-api-types
• packages/api-server (torrust-tracker-api-server) <- depends on torrust-tracker-api-types. Maybe in the future

IMPORTANT: the implementation in the Index was improved. We have to apply those improvements to this client.

[josecelano]

The current implementation in the Index with some improvements like a timeout for requests:

use std::time::Duration;

use reqwest::{Error, Response};
use url::Url;
pub struct ConnectionInfo {
    /// The URL of the tracker API. Eg: <https://tracker:1212>.
    pub url: Url,
    /// The token used to authenticate with the tracker API.
    pub token: String,
}

impl ConnectionInfo {
    #[must_use]
    pub fn new(url: Url, token: String) -> Self {
        Self { url, token }
    }
}

const TOKEN_PARAM_NAME: &str = "token";
const API_PATH: &str = "api/v1";
const TOTAL_REQUEST_TIMEOUT_IN_SECS: u64 = 5;

pub struct Client {
    pub connection_info: ConnectionInfo,
    api_base_url: Url,
    client: reqwest::Client,
    token_param: [(String, String); 1],
}

impl Client {
    /// # Errors
    ///
    /// Will fails if it can't build a HTTP client with a timeout.
    ///
    /// # Panics
    ///
    /// Will panic if the API base URL is not valid.
    pub fn new(connection_info: ConnectionInfo) -> Result<Self, Error> {
        let api_base_url = connection_info.url.join(API_PATH).expect("valid URL API path");
        let client = reqwest::Client::builder()
            .timeout(Duration::from_secs(TOTAL_REQUEST_TIMEOUT_IN_SECS))
            .build()?;
        let token_param = [(TOKEN_PARAM_NAME.to_string(), connection_info.token.to_string())];

        Ok(Self {
            connection_info,
            api_base_url,
            client,
            token_param,
        })
    }

    /// Add a torrent to the tracker whitelist.
    ///
    /// # Errors
    ///
    /// Will return an error if the HTTP request fails.
    pub async fn whitelist_torrent(&self, info_hash: &str) -> Result<Response, Error> {
        let request_url = format!("{}/whitelist/{}", self.api_base_url, info_hash);

        self.client.post(request_url).query(&self.token_param).send().await
    }

    /// Remove a torrent from the tracker whitelist.
    ///
    /// # Errors
    ///
    /// Will return an error if the HTTP request fails.
    pub async fn remove_torrent_from_whitelist(&self, info_hash: &str) -> Result<Response, Error> {
        let request_url = format!("{}/whitelist/{}", self.api_base_url, info_hash);

        self.client.delete(request_url).query(&self.token_param).send().await
    }

    /// Retrieve a new tracker key.
    ///
    /// # Errors
    ///
    /// Will return an error if the HTTP request fails.
    pub async fn retrieve_new_tracker_key(&self, token_valid_seconds: u64) -> Result<Response, Error> {
        let request_url = format!("{}/key/{}", self.api_base_url, token_valid_seconds);

        self.client.post(request_url).query(&self.token_param).send().await
    }

    /// Retrieve the info for one torrent.
    ///
    /// # Errors
    ///
    /// Will return an error if the HTTP request fails.
    pub async fn get_torrent_info(&self, info_hash: &str) -> Result<Response, Error> {
        let request_url = format!("{}/torrent/{}", self.api_base_url, info_hash);

        self.client.get(request_url).query(&self.token_param).send().await
    }

    /// Retrieve the info for multiple torrents at the same time.
    ///
    /// # Errors
    ///
    /// Will return an error if the HTTP request fails.
    pub async fn get_torrents_info(&self, info_hashes: &[String]) -> Result<Response, Error> {
        let request_url = format!("{}/torrents", self.api_base_url);

        let mut query_params: Vec<(String, String)> = Vec::with_capacity(info_hashes.len() + 1);

        query_params.push((TOKEN_PARAM_NAME.to_string(), self.connection_info.token.clone()));

        for info_hash in info_hashes {
            query_params.push(("info_hash".to_string(), info_hash.clone()));
        }

        self.client.get(request_url).query(&query_params).send().await
    }
}