dev: cleanup bootstrap of services

packages/configuration/src/lib.rs

@@ -239,7 +239,7 @@ use config::{Config, ConfigError, File, FileFormat};
 use serde::{Deserialize, Serialize};
 use serde_with::{serde_as, NoneAsEmptyString};
 use thiserror::Error;
-use torrust_tracker_located_error::{Located, LocatedError};
+use torrust_tracker_located_error::{DynError, Located, LocatedError};
 use torrust_tracker_primitives::{DatabaseDriver, TrackerMode};
 
 /// Information required for loading config
@@ -289,7 +289,7 @@ impl Info {
 
             fs::read_to_string(config_path)
                 .map_err(|e| Error::UnableToLoadFromConfigFile {
-                    source: (Arc::new(e) as Arc<dyn std::error::Error + Send + Sync>).into(),
+                    source: (Arc::new(e) as DynError).into(),
                 })?
                 .parse()
                 .map_err(|_e: std::convert::Infallible| Error::Infallible)?

packages/located-error/src/lib.rs

@@ -33,6 +33,8 @@ use std::error::Error;
 use std::panic::Location;
 use std::sync::Arc;
 
+pub type DynError = Arc<dyn std::error::Error + Send + Sync>;
+
 /// A generic wrapper around an error.
 ///
 /// Where `E` is the inner error (source error).
@@ -96,7 +98,7 @@ where
 }
 
 #[allow(clippy::from_over_into)]
-impl<'a> Into<LocatedError<'a, dyn std::error::Error + Send + Sync>> for Arc<dyn std::error::Error + Send + Sync> {
+impl<'a> Into<LocatedError<'a, dyn std::error::Error + Send + Sync>> for DynError {
     #[track_caller]
     fn into(self) -> LocatedError<'a, dyn std::error::Error + Send + Sync> {
         LocatedError {

src/bootstrap/jobs/http_tracker.rs

@@ -18,6 +18,7 @@ use log::info;
 use tokio::task::JoinHandle;
 use torrust_tracker_configuration::HttpTracker;
 
+use super::make_rust_tls;
 use crate::core;
 use crate::servers::http::server::{HttpServer, HttpServerLauncher};
 use crate::servers::http::v1::launcher::Launcher;
@@ -39,17 +40,9 @@ pub async fn start_job(config: &HttpTracker, tracker: Arc<core::Tracker>, versio
             .parse::<std::net::SocketAddr>()
             .expect("Tracker API bind_address invalid.");
 
-        let tls = if let (true, Some(cert), Some(key)) = (&config.ssl_enabled, &config.ssl_cert_path, &config.ssl_key_path) {
-            let tls = RustlsConfig::from_pem_file(cert, key)
-                .await
-                .expect("Could not read tls cert.");
-            info!("Using https: cert path: {cert}.");
-            info!("Using https: key path: {cert}.");
-            Some(tls)
-        } else {
-            info!("Loading HTTP tracker without TLS.");
-            None
-        };
+        let tls = make_rust_tls(config.ssl_enabled, &config.ssl_cert_path, &config.ssl_key_path)
+            .await
+            .map(|tls| tls.expect("tls config failed"));
 
         match version {
             Version::V1 => Some(start_v1(socket, tls, tracker.clone()).await),

src/bootstrap/jobs/mod.rs

@@ -19,3 +19,49 @@ pub mod udp_tracker;
 pub struct Started {
     pub address: std::net::SocketAddr,
 }
+
+pub async fn make_rust_tls(enabled: bool, cert: &Option<String>, key: &Option<String>) -> Option<Result<RustlsConfig, Error>> {
+    if enabled {
+        if let (Some(cert), Some(key)) = (cert, key) {
+            info!("Using https: cert path: {cert}.");
+            info!("Using https: key path: {cert}.");
+
+            Some(
+                RustlsConfig::from_pem_file(cert, key)
+                    .await
+                    .map_err(|err| Error::BadTlsConfig {
+                        source: (Arc::new(err) as DynError).into(),
+                    }),
+            )
+        } else {
+            Some(Err(Error::MissingTlsConfig {
+                location: Location::caller(),
+            }))
+        }
+    } else {
+        info!("tls not enabled");
+        None
+    }
+}
+
+use std::panic::Location;
+use std::sync::Arc;
+
+use axum_server::tls_rustls::RustlsConfig;
+use log::info;
+use thiserror::Error;
+use torrust_tracker_located_error::{DynError, LocatedError};
+
+/// Error returned by the Bootstrap Process.
+#[derive(Error, Debug)]
+pub enum Error {
+    /// Enabled tls but missing config.
+    #[error("tls config missing")]
+    MissingTlsConfig { location: &'static Location<'static> },
+
+    /// Unable to parse tls Config.
+    #[error("bad tls config: {source}")]
+    BadTlsConfig {
+        source: LocatedError<'static, dyn std::error::Error + Send + Sync>,
+    },
+}

src/bootstrap/jobs/tracker_apis.rs

@@ -28,6 +28,7 @@ use log::info;
 use tokio::task::JoinHandle;
 use torrust_tracker_configuration::HttpApi;
 
+use super::make_rust_tls;
 use crate::core;
 use crate::servers::apis::server::{ApiServer, Launcher};
 use crate::servers::apis::Version;
@@ -54,25 +55,17 @@ pub struct ApiServerJobStarted();
 ///
 pub async fn start_job(config: &HttpApi, tracker: Arc<core::Tracker>, version: Version) -> Option<JoinHandle<()>> {
     if config.enabled {
-        let socket = config
+        let bind_to = config
             .bind_address
             .parse::<std::net::SocketAddr>()
             .expect("Tracker API bind_address invalid.");
 
-        let tls = if let (true, Some(cert), Some(key)) = (&config.ssl_enabled, &config.ssl_cert_path, &config.ssl_key_path) {
-            let tls = RustlsConfig::from_pem_file(cert, key)
-                .await
-                .expect("Could not read tls cert.");
-            info!("Using https: cert path: {cert}.");
-            info!("Using https: key path: {cert}.");
-            Some(tls)
-        } else {
-            info!("Loading HTTP tracker without TLS.");
-            None
-        };
+        let tls = make_rust_tls(config.ssl_enabled, &config.ssl_cert_path, &config.ssl_key_path)
+            .await
+            .map(|tls| tls.expect("tls config failed"));
 
         match version {
-            Version::V1 => Some(start_v1(socket, tls, tracker.clone()).await),
+            Version::V1 => Some(start_v1(bind_to, tls, tracker.clone()).await),
         }
     } else {
         info!("Note: Not loading Http Tracker Service, Not Enabled in Configuration.");

src/core/auth.rs

@@ -47,7 +47,7 @@ use rand::distributions::Alphanumeric;
 use rand::{thread_rng, Rng};
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
-use torrust_tracker_located_error::LocatedError;
+use torrust_tracker_located_error::{DynError, LocatedError};
 
 use crate::shared::bit_torrent::common::AUTH_KEY_LENGTH;
 use crate::shared::clock::{convert_from_timestamp_to_datetime_utc, Current, DurationSinceUnixEpoch, Time, TimeNow};
@@ -185,7 +185,7 @@ pub enum Error {
 impl From<r2d2_sqlite::rusqlite::Error> for Error {
     fn from(e: r2d2_sqlite::rusqlite::Error) -> Self {
         Error::KeyVerificationError {
-            source: (Arc::new(e) as Arc<dyn std::error::Error + Send + Sync>).into(),
+            source: (Arc::new(e) as DynError).into(),
         }
     }
 }

src/core/databases/error.rs

@@ -5,7 +5,7 @@ use std::panic::Location;
 use std::sync::Arc;
 
 use r2d2_mysql::mysql::UrlError;
-use torrust_tracker_located_error::{Located, LocatedError};
+use torrust_tracker_located_error::{DynError, Located, LocatedError};
 use torrust_tracker_primitives::DatabaseDriver;
 
 #[derive(thiserror::Error, Debug, Clone)]
@@ -59,11 +59,11 @@ impl From<r2d2_sqlite::rusqlite::Error> for Error {
     fn from(err: r2d2_sqlite::rusqlite::Error) -> Self {
         match err {
             r2d2_sqlite::rusqlite::Error::QueryReturnedNoRows => Error::QueryReturnedNoRows {
-                source: (Arc::new(err) as Arc<dyn std::error::Error + Send + Sync>).into(),
+                source: (Arc::new(err) as DynError).into(),
                 driver: DatabaseDriver::Sqlite3,
             },
             _ => Error::InvalidQuery {
-                source: (Arc::new(err) as Arc<dyn std::error::Error + Send + Sync>).into(),
+                source: (Arc::new(err) as DynError).into(),
                 driver: DatabaseDriver::Sqlite3,
             },
         }
@@ -73,7 +73,7 @@ impl From<r2d2_sqlite::rusqlite::Error> for Error {
 impl From<r2d2_mysql::mysql::Error> for Error {
     #[track_caller]
     fn from(err: r2d2_mysql::mysql::Error) -> Self {
-        let e: Arc<dyn std::error::Error + Send + Sync> = Arc::new(err);
+        let e: DynError = Arc::new(err);
         Error::InvalidQuery {
             source: e.into(),
             driver: DatabaseDriver::MySQL,

src/core/mod.rs

@@ -448,6 +448,7 @@ use std::time::Duration;
 use futures::future::join_all;
 use tokio::sync::mpsc::error::SendError;
 use torrust_tracker_configuration::Configuration;
+use torrust_tracker_located_error::DynError;
 use torrust_tracker_primitives::TrackerMode;
 
 use self::auth::Key;
@@ -933,7 +934,7 @@ impl Tracker {
                     if let Err(e) = self.verify_auth_key(key).await {
                         return Err(Error::PeerKeyNotValid {
                             key: key.clone(),
-                            source: (Arc::new(e) as Arc<dyn std::error::Error + Send + Sync>).into(),
+                            source: (Arc::new(e) as DynError).into(),
                         });
                     }
                 }

src/servers/apis/server.rs

@@ -35,7 +35,7 @@ use tokio::sync::oneshot::{Receiver, Sender};
 use super::routes::router;
 use crate::bootstrap::jobs::Started;
 use crate::core::Tracker;
-use crate::servers::signals::{shutdown_signal_with_message, Halted};
+use crate::servers::signals::{graceful_shutdown, Halted};
 
 /// Errors that can occur when starting or stopping the API server.
 #[derive(Debug)]
@@ -97,10 +97,7 @@ impl ApiServer<Stopped> {
         let launcher = self.state.launcher;
 
         let task = tokio::spawn(async move {
-            let server = launcher.start(tracker, tx_start, rx_halt);
-
-            server.await;
-
+            launcher.start(tracker, tx_start, rx_halt).await;
             launcher
         });
 
@@ -153,30 +150,30 @@ impl Launcher {
     /// Will panic if unable to bind to the socket, or unable to get the address of the bound socket.
     /// Will also panic if unable to send message regarding the bound socket address.
     pub fn start(&self, tracker: Arc<Tracker>, tx_start: Sender<Started>, rx_halt: Receiver<Halted>) -> BoxFuture<'static, ()> {
-        let app = router(tracker);
+        let router = router(tracker);
         let socket = std::net::TcpListener::bind(self.bind_to).expect("Could not bind tcp_listener to address.");
         let address = socket.local_addr().expect("Could not get local_addr from tcp_listener.");
 
         let handle = Handle::new();
-        let handel_cloned = handle.clone();
 
-        tokio::task::spawn(async move {
-            shutdown_signal_with_message(rx_halt, format!("Halting API Service Bound to Socket: {address}")).await;
-            handel_cloned.graceful_shutdown(None);
-        });
+        tokio::task::spawn(graceful_shutdown(
+            handle.clone(),
+            rx_halt,
+            format!("shutting down http server on socket address: {address}"),
+        ));
 
         let tls = self.tls.clone();
 
         let running = Box::pin(async {
             match tls {
                 Some(tls) => axum_server::from_tcp_rustls(socket, tls)
                     .handle(handle)
-                    .serve(app.into_make_service_with_connect_info::<std::net::SocketAddr>())
+                    .serve(router.into_make_service_with_connect_info::<std::net::SocketAddr>())
                     .await
                     .expect("Axum server crashed."),
                 None => axum_server::from_tcp(socket)
                     .handle(handle)
-                    .serve(app.into_make_service_with_connect_info::<std::net::SocketAddr>())
+                    .serve(router.into_make_service_with_connect_info::<std::net::SocketAddr>())
                     .await
                     .expect("Axum server crashed."),
             }
@@ -194,37 +191,31 @@ impl Launcher {
 mod tests {
     use std::sync::Arc;
 
-    use torrust_tracker_configuration::Configuration;
-    use torrust_tracker_test_helpers::configuration;
+    use torrust_tracker_test_helpers::configuration::ephemeral_mode_public;
 
-    use crate::core;
-    use crate::core::statistics;
+    use crate::bootstrap::app::initialize_with_configuration;
+    use crate::bootstrap::jobs::make_rust_tls;
     use crate::servers::apis::server::{ApiServer, Launcher};
 
-    fn tracker_configuration() -> Arc<Configuration> {
-        Arc::new(configuration::ephemeral())
-    }
-
     #[tokio::test]
-    async fn it_should_be_able_to_start_from_stopped_state_and_then_stop_again() {
-        let cfg = tracker_configuration();
-
-        let tracker = Arc::new(core::Tracker::new(cfg.clone(), None, statistics::Repo::new()).unwrap());
+    async fn it_should_be_able_to_start_and_stop() {
+        let cfg = Arc::new(ephemeral_mode_public());
+        let tracker = initialize_with_configuration(&cfg);
+        let config = &cfg.http_trackers[0];
 
-        let bind_to = cfg
-            .http_api
+        let bind_to = config
             .bind_address
             .parse::<std::net::SocketAddr>()
             .expect("Tracker API bind_address invalid.");
 
-        let stopped_api_server = ApiServer::new(Launcher::new(bind_to, None));
-
-        let running_api_server_result = stopped_api_server.start(tracker).await;
-
-        assert!(running_api_server_result.is_ok());
+        let tls = make_rust_tls(config.ssl_enabled, &config.ssl_cert_path, &config.ssl_key_path)
+            .await
+            .map(|tls| tls.expect("tls config failed"));
 
-        let running_api_server = running_api_server_result.unwrap();
+        let stopped = ApiServer::new(Launcher::new(bind_to, tls));
+        let started = stopped.start(tracker).await.expect("it should start the server");
+        let stopped = started.stop().await.expect("it should stop the server");
 
-        assert!(running_api_server.stop().await.is_ok());
+        assert_eq!(stopped.state.launcher.bind_to, bind_to);
     }
 }

src/servers/http/server.rs

@@ -144,3 +144,37 @@ impl<I: HttpServerLauncher> HttpServer<Running<I>> {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use torrust_tracker_test_helpers::configuration::ephemeral_mode_public;
+
+    use crate::bootstrap::app::initialize_with_configuration;
+    use crate::bootstrap::jobs::make_rust_tls;
+    use crate::servers::http::server::{HttpServer, HttpServerLauncher};
+    use crate::servers::http::v1::launcher::Launcher;
+
+    #[tokio::test]
+    async fn it_should_be_able_to_start_and_stop() {
+        let cfg = Arc::new(ephemeral_mode_public());
+        let tracker = initialize_with_configuration(&cfg);
+        let config = &cfg.http_trackers[0];
+
+        let bind_to = config
+            .bind_address
+            .parse::<std::net::SocketAddr>()
+            .expect("Tracker API bind_address invalid.");
+
+        let tls = make_rust_tls(config.ssl_enabled, &config.ssl_cert_path, &config.ssl_key_path)
+            .await
+            .map(|tls| tls.expect("tls config failed"));
+
+        let stopped = HttpServer::new(Launcher::new(bind_to, tls));
+        let started = stopped.start(tracker).await.expect("it should start the server");
+        let stopped = started.stop().await.expect("it should stop the server");
+
+        assert_eq!(stopped.state.launcher.bind_to, bind_to);
+    }
+}