Add tests for the HTTP tracker

Cargo.toml

@@ -61,6 +61,11 @@ uuid = { version = "1", features = ["v4"] }
 axum = "0.6.1"
 axum-server = { version = "0.4.4", features = ["tls-rustls"] }
 
+
 [dev-dependencies]
 mockall = "0.11"
 reqwest = { version = "0.11.13", features = ["json"] }
+serde_urlencoded = "0.7.1"
+serde_repr = "0.1.10"
+serde_bytes = "0.11.8"
+local-ip-address = "0.5.1"

cSpell.json

@@ -6,6 +6,7 @@
         "Avicora",
         "Azureus",
         "bencode",
+        "bencoded",
         "binascii",
         "Bitflu",
         "bools",
@@ -39,6 +40,7 @@
         "nanos",
         "nextest",
         "nocapture",
+        "numwant",
         "oneshot",
         "ostr",
         "Pando",
@@ -62,12 +64,16 @@
         "Torrentstorm",
         "torrust",
         "torrustracker",
+        "trackerid",
         "typenum",
         "Unamed",
         "untuple",
         "uroot",
         "Vagaa",
+        "Vuze",
         "Xtorrent",
-        "Xunlei"
+        "Xunlei",
+        "xxxxxxxxxxxxxxxxxxxxd",
+        "yyyyyyyyyyyyyyyyyyyyd"
     ]
 }

src/apis/middlewares/auth.rs

@@ -25,10 +25,7 @@ pub async fn auth<B>(
 where
     B: Send,
 {
-    let token = match params.token {
-        None => return AuthError::Unauthorized.into_response(),
-        Some(token) => token,
-    };
+    let Some(token) = params.token else { return AuthError::Unauthorized.into_response() };
 
     if !authenticate(&token, &config.http_api) {
         return AuthError::TokenNotValid.into_response();

src/apis/resources/peer.rs

@@ -24,7 +24,7 @@ pub struct Id {
 impl From<tracker::peer::Id> for Id {
     fn from(peer_id: tracker::peer::Id) -> Self {
         Id {
-            id: peer_id.get_id(),
+            id: peer_id.to_hex_string(),
             client: peer_id.get_client_name().map(std::string::ToString::to_string),
         }
     }

src/apis/responses.rs

@@ -86,8 +86,7 @@ pub fn ok_response() -> Response {
 #[must_use]
 pub fn invalid_info_hash_param_response(info_hash: &str) -> Response {
     bad_request_response(&format!(
-        "Invalid URL: invalid infohash param: string \"{}\", expected a 40 character long string",
-        info_hash
+        "Invalid URL: invalid infohash param: string \"{info_hash}\", expected a 40 character long string"
     ))
 }
 

src/config.rs

@@ -84,27 +84,39 @@ pub enum Error {
 }
 
 /// This configuration is used for testing. It generates random config values so they do not collide
-/// if  you run more than one tracker at the same time.
+/// if you run more than one tracker at the same time.
 ///
 /// # Panics
 ///
 /// Will panic if it can't convert the temp file path to string
 #[must_use]
 pub fn ephemeral_configuration() -> Configuration {
+    // todo: disable services that are not needed.
+    // For example: a test for the UDP tracker should disable the API and HTTP tracker.
+
     let mut config = Configuration {
-        log_level: Some("off".to_owned()),
+        log_level: Some("off".to_owned()), // Change to `debug` for tests debugging
         ..Default::default()
     };
 
-    // Ephemeral socket addresses
+    // Ephemeral socket address for API
     let api_port = random_port();
+    config.http_api.enabled = true;
     config.http_api.bind_address = format!("127.0.0.1:{}", &api_port);
+
+    // Ephemeral socket address for UDP tracker
     let upd_port = random_port();
+    config.udp_trackers[0].enabled = true;
     config.udp_trackers[0].bind_address = format!("127.0.0.1:{}", &upd_port);
 
+    // Ephemeral socket address for HTTP tracker
+    let http_port = random_port();
+    config.http_trackers[0].enabled = true;
+    config.http_trackers[0].bind_address = format!("127.0.0.1:{}", &http_port);
+
     // Ephemeral sqlite database
     let temp_directory = env::temp_dir();
-    let temp_file = temp_directory.join(format!("data_{}_{}.db", &api_port, &upd_port));
+    let temp_file = temp_directory.join(format!("data_{}_{}_{}.db", &api_port, &upd_port, &http_port));
     config.db_path = temp_file.to_str().unwrap().to_owned();
 
     config

src/http/mod.rs

@@ -1,3 +1,14 @@
+//! Tracker HTTP/HTTPS Protocol:
+//!
+//! Original specification in BEP 3 (section "Trackers"):
+//!
+//! <https://www.bittorrent.org/beps/bep_0003.html>
+//!
+//! Other resources:
+//!
+//! - <https://wiki.theory.org/BitTorrentSpecification#Tracker_HTTP.2FHTTPS_Protocol>
+//! - <https://wiki.theory.org/BitTorrent_Tracker_Protocol>
+//!
 pub mod error;
 pub mod filters;
 pub mod handlers;

src/http/response.rs

@@ -2,19 +2,18 @@ use std::collections::HashMap;
 use std::io::Write;
 use std::net::IpAddr;
 
-use serde;
-use serde::Serialize;
+use serde::{self, Deserialize, Serialize};
 
 use crate::protocol::info_hash::InfoHash;
 
-#[derive(Serialize)]
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
 pub struct Peer {
     pub peer_id: String,
     pub ip: IpAddr,
     pub port: u16,
 }
 
-#[derive(Serialize)]
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
 pub struct Announce {
     pub interval: u32,
     #[serde(rename = "min interval")]

src/jobs/http_tracker.rs

@@ -2,35 +2,69 @@ use std::net::SocketAddr;
 use std::sync::Arc;
 
 use log::{info, warn};
+use tokio::sync::oneshot;
 use tokio::task::JoinHandle;
 
 use crate::config::HttpTracker;
 use crate::http::server::Http;
 use crate::tracker;
 
+#[derive(Debug)]
+pub struct ServerJobStarted();
+
 /// # Panics
 ///
 /// It would panic if the `config::HttpTracker` struct would contain an inappropriate values.
-#[must_use]
-pub fn start_job(config: &HttpTracker, tracker: Arc<tracker::Tracker>) -> JoinHandle<()> {
-    let bind_addr = config.bind_address.parse::<SocketAddr>().unwrap();
+pub async fn start_job(config: &HttpTracker, tracker: Arc<tracker::Tracker>) -> JoinHandle<()> {
+    let bind_addr = config
+        .bind_address
+        .parse::<SocketAddr>()
+        .expect("HTTP tracker server bind_address invalid.");
     let ssl_enabled = config.ssl_enabled;
     let ssl_cert_path = config.ssl_cert_path.clone();
     let ssl_key_path = config.ssl_key_path.clone();
 
-    tokio::spawn(async move {
+    let (tx, rx) = oneshot::channel::<ServerJobStarted>();
+
+    // Run the HTTP tracker server
+    let join_handle = tokio::spawn(async move {
         let http_tracker = Http::new(tracker);
 
         if !ssl_enabled {
-            info!("Starting HTTP server on: http://{}", bind_addr);
-            http_tracker.start(bind_addr).await;
+            info!("Starting HTTP tracker server on: http://{}", bind_addr);
+
+            let handle = http_tracker.start(bind_addr);
+
+            tx.send(ServerJobStarted())
+                .expect("HTTP tracker server should not be dropped");
+
+            handle.await;
+
+            info!("HTTP tracker server on http://{} stopped", bind_addr);
         } else if ssl_enabled && ssl_cert_path.is_some() && ssl_key_path.is_some() {
-            info!("Starting HTTPS server on: https://{} (TLS)", bind_addr);
-            http_tracker
-                .start_tls(bind_addr, ssl_cert_path.unwrap(), ssl_key_path.unwrap())
-                .await;
+            info!("Starting HTTPS server on: https://{}", bind_addr);
+
+            let handle = http_tracker.start_tls(bind_addr, ssl_cert_path.unwrap(), ssl_key_path.unwrap());
+
+            tx.send(ServerJobStarted())
+                .expect("HTTP tracker server should not be dropped");
+
+            handle.await;
+
+            info!("HTTP tracker server on https://{} stopped", bind_addr);
         } else {
-            warn!("Could not start HTTP tracker on: {}, missing SSL Cert or Key!", bind_addr);
+            warn!(
+                "Could not start HTTPS tracker server on: {}, missing SSL Cert or Key!",
+                bind_addr
+            );
         }
-    })
+    });
+
+    // Wait until the HTTPS tracker server job is running
+    match rx.await {
+        Ok(_msg) => info!("HTTP tracker server started"),
+        Err(e) => panic!("HTTP tracker server was dropped: {e}"),
+    }
+
+    join_handle
 }

src/protocol/info_hash.rs

@@ -1,6 +1,14 @@
 #[derive(PartialEq, Eq, Hash, Clone, Copy, Debug)]
 pub struct InfoHash(pub [u8; 20]);
 
+impl InfoHash {
+    /// For readability, when accessing the bytes array
+    #[must_use]
+    pub fn bytes(&self) -> [u8; 20] {
+        self.0
+    }
+}
+
 impl std::fmt::Display for InfoHash {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         let mut chars = [0u8; 40];

src/setup.rs

@@ -47,7 +47,7 @@ pub async fn setup(config: &Configuration, tracker: Arc<tracker::Tracker>) -> Ve
         if !http_tracker_config.enabled {
             continue;
         }
-        jobs.push(http_tracker::start_job(http_tracker_config, tracker.clone()));
+        jobs.push(http_tracker::start_job(http_tracker_config, tracker.clone()).await);
     }
 
     // Start HTTP API