feat(http): [#160] scaffolding for HTTP tracker using Axum

We are going to migrate the HTTP tracker from Warp to Axum.
This is the basic scaffolding for Axum. Tests have been duplicated to
test the new Axum implementation. The setup allows executing both
versions: the Warp version on production and both versions (Warp and
Axum) on testing env.

Author: josecelano

src/http/axum/handlers.rs

@@ -0,0 +1,9 @@
+use axum::response::Json;
+
+use super::resources::ok::Ok;
+use super::responses::ok_response;
+
+#[allow(clippy::unused_async)]
+pub async fn get_status_handler() -> Json<Ok> {
+    ok_response()
+}

src/http/axum/mod.rs

@@ -0,0 +1,5 @@
+pub mod handlers;
+pub mod resources;
+pub mod responses;
+pub mod routes;
+pub mod server;

src/http/axum/resources/mod.rs

@@ -0,0 +1 @@
+pub mod ok;

src/http/axum/resources/ok.rs

@@ -0,0 +1,4 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
+pub struct Ok {}

src/http/axum/responses.rs

@@ -0,0 +1,10 @@
+// Resource responses
+
+use axum::Json;
+
+use super::resources::ok::Ok;
+
+#[must_use]
+pub fn ok_response() -> Json<Ok> {
+    Json(Ok {})
+}

src/http/axum/routes.rs

@@ -0,0 +1,13 @@
+use std::sync::Arc;
+
+use axum::routing::get;
+use axum::Router;
+
+use super::handlers::get_status_handler;
+use crate::tracker::Tracker;
+
+pub fn router(_tracker: &Arc<Tracker>) -> Router {
+    Router::new()
+        // Status
+        .route("/status", get(get_status_handler))
+}

src/http/axum/server.rs

@@ -0,0 +1,43 @@
+use std::net::SocketAddr;
+use std::sync::Arc;
+
+use axum_server::tls_rustls::RustlsConfig;
+use axum_server::Handle;
+use futures::Future;
+use log::info;
+use warp::hyper;
+
+use super::routes::router;
+use crate::tracker::Tracker;
+
+pub fn start(socket_addr: SocketAddr, tracker: &Arc<Tracker>) -> impl Future<Output = hyper::Result<()>> {
+    let app = router(tracker);
+
+    let server = axum::Server::bind(&socket_addr).serve(app.into_make_service());
+
+    server.with_graceful_shutdown(async move {
+        tokio::signal::ctrl_c().await.expect("Failed to listen to shutdown signal.");
+        info!("Stopping Torrust HTTP tracker server on http://{} ...", socket_addr);
+    })
+}
+
+pub fn start_tls(
+    socket_addr: SocketAddr,
+    ssl_config: RustlsConfig,
+    tracker: &Arc<Tracker>,
+) -> impl Future<Output = Result<(), std::io::Error>> {
+    let app = router(tracker);
+
+    let handle = Handle::new();
+    let shutdown_handle = handle.clone();
+
+    tokio::spawn(async move {
+        tokio::signal::ctrl_c().await.expect("Failed to listen to shutdown signal.");
+        info!("Stopping Torrust HTTP tracker server on https://{} ...", socket_addr);
+        shutdown_handle.shutdown();
+    });
+
+    axum_server::bind_rustls(socket_addr, ssl_config)
+        .handle(handle)
+        .serve(app.into_make_service())
+}

src/http/mod.rs

@@ -9,6 +9,9 @@
 //! - <https://wiki.theory.org/BitTorrentSpecification#Tracker_HTTP.2FHTTPS_Protocol>
 //! - <https://wiki.theory.org/BitTorrent_Tracker_Protocol>
 //!
+
+use serde::{Deserialize, Serialize};
+pub mod axum;
 pub mod error;
 pub mod filters;
 pub mod handlers;
@@ -19,3 +22,9 @@ pub mod server;
 
 pub type Bytes = u64;
 pub type WebResult<T> = std::result::Result<T, warp::Rejection>;
+
+#[derive(Serialize, Deserialize, Copy, Clone, PartialEq, Eq, Debug)]
+pub enum Version {
+    Warp,
+    Axum,
+}

src/jobs/http_tracker.rs

@@ -1,21 +1,31 @@
 use std::net::SocketAddr;
 use std::sync::Arc;
 
+use axum_server::tls_rustls::RustlsConfig;
 use log::{info, warn};
 use tokio::sync::oneshot;
 use tokio::task::JoinHandle;
 
 use crate::config::HttpTracker;
+use crate::http::axum::server;
 use crate::http::server::Http;
+use crate::http::Version;
 use crate::tracker;
 
 #[derive(Debug)]
 pub struct ServerJobStarted();
 
+pub async fn start_job(config: &HttpTracker, tracker: Arc<tracker::Tracker>, version: Version) -> JoinHandle<()> {
+    match version {
+        Version::Warp => start_warp(config, tracker.clone()).await,
+        Version::Axum => start_axum(config, tracker.clone()).await,
+    }
+}
+
 /// # Panics
 ///
-/// It would panic if the `config::HttpTracker` struct would contain an inappropriate values.
-pub async fn start_job(config: &HttpTracker, tracker: Arc<tracker::Tracker>) -> JoinHandle<()> {
+/// It would panic if the `config::HttpTracker` struct would contain inappropriate values.
+async fn start_warp(config: &HttpTracker, tracker: Arc<tracker::Tracker>) -> JoinHandle<()> {
     let bind_addr = config
         .bind_address
         .parse::<SocketAddr>()
@@ -68,3 +78,57 @@ pub async fn start_job(config: &HttpTracker, tracker: Arc<tracker::Tracker>) ->
 
     join_handle
 }
+
+/// # Panics
+///
+/// It would panic if the `config::HttpTracker` struct would contain inappropriate values.
+async fn start_axum(config: &HttpTracker, tracker: Arc<tracker::Tracker>) -> JoinHandle<()> {
+    let bind_addr = config
+        .bind_address
+        .parse::<std::net::SocketAddr>()
+        .expect("Tracker API 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();
+
+    let (tx, rx) = oneshot::channel::<ServerJobStarted>();
+
+    // Run the API server
+    let join_handle = tokio::spawn(async move {
+        if !ssl_enabled {
+            info!("Starting Torrust HTTP tracker server on: http://{}", bind_addr);
+
+            let handle = server::start(bind_addr, &tracker);
+
+            tx.send(ServerJobStarted())
+                .expect("the HTTP tracker server should not be dropped");
+
+            if let Ok(()) = handle.await {
+                info!("Torrust HTTP tracker server on http://{} stopped", bind_addr);
+            }
+        } else if ssl_enabled && ssl_cert_path.is_some() && ssl_key_path.is_some() {
+            info!("Starting Torrust HTTP tracker server on: https://{}", bind_addr);
+
+            let ssl_config = RustlsConfig::from_pem_file(ssl_cert_path.unwrap(), ssl_key_path.unwrap())
+                .await
+                .unwrap();
+
+            let handle = server::start_tls(bind_addr, ssl_config, &tracker);
+
+            tx.send(ServerJobStarted())
+                .expect("the HTTP tracker server should not be dropped");
+
+            if let Ok(()) = handle.await {
+                info!("Torrust HTTP tracker server on https://{} stopped", bind_addr);
+            }
+        }
+    });
+
+    // Wait until the HTTP tracker server job is running
+    match rx.await {
+        Ok(_msg) => info!("Torrust HTTP tracker server started"),
+        Err(e) => panic!("the HTTP tracker server was dropped: {e}"),
+    }
+
+    join_handle
+}

src/setup.rs

@@ -4,6 +4,7 @@ use log::warn;
 use tokio::task::JoinHandle;
 
 use crate::config::Configuration;
+use crate::http::Version;
 use crate::jobs::{http_tracker, torrent_cleanup, tracker_apis, udp_tracker};
 use crate::tracker;
 
@@ -47,7 +48,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()).await);
+        jobs.push(http_tracker::start_job(http_tracker_config, tracker.clone(), Version::Warp).await);
     }
 
     // Start HTTP API