refactor: [torrust#521]: validate HTTP tracker config before starting the service

It shows a more friendly error message and it's easier to test.

Author: josecelano

packages/configuration/src/http_tracker.rs

@@ -0,0 +1,182 @@
+//! Validated configuration for the HTTP Tracker service.
+//!
+//! [``crate::HttpTracker``] is a DTO containing the parsed data from the toml
+//! file.
+//!
+//! This configuration is a first level of validation that can be perform
+//! statically without running the service.
+//!
+//! For example, if SSL is enabled you must provide the certificate path. That
+//! can be validated. However, this validation does not check if the
+//! certificate is valid.
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+use crate::HttpTracker;
+
+/// Errors that can occur when validating the plan configuration.
+#[derive(Error, Debug, PartialEq)]
+pub enum ValidationError {
+    /// Missing SSL cert path.
+    #[error("missing SSL cert path, got: {ssl_cert_path}")]
+    MissingSslCertPath { ssl_cert_path: String },
+    /// Missing SSL key path.
+    #[error("missing SSL key path, got: {ssl_key_path}")]
+    MissingSslKeyPath { ssl_key_path: String },
+}
+
+/// Configuration for each HTTP tracker.
+#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
+pub struct Config {
+    enabled: bool,
+    bind_address: String, // todo: use SocketAddr
+    ssl_enabled: bool,
+    ssl_cert_path: Option<String>, // todo: use Path
+    ssl_key_path: Option<String>,  // todo: use Path
+}
+
+impl Config {
+    #[must_use]
+    pub fn is_enabled(&self) -> bool {
+        self.enabled
+    }
+}
+
+impl TryFrom<HttpTracker> for Config {
+    type Error = ValidationError;
+
+    fn try_from(config: HttpTracker) -> Result<Self, Self::Error> {
+        if config.ssl_enabled {
+            match config.ssl_cert_path.clone() {
+                Some(ssl_cert_path) => {
+                    if ssl_cert_path.is_empty() {
+                        Err(ValidationError::MissingSslCertPath {
+                            ssl_cert_path: String::new(),
+                        })
+                    } else {
+                        Ok(())
+                    }
+                }
+                None => Err(ValidationError::MissingSslCertPath {
+                    ssl_cert_path: String::new(),
+                }),
+            }?;
+
+            match config.ssl_key_path.clone() {
+                Some(ssl_key_path) => {
+                    if ssl_key_path.is_empty() {
+                        Err(ValidationError::MissingSslKeyPath {
+                            ssl_key_path: String::new(),
+                        })
+                    } else {
+                        Ok(())
+                    }
+                }
+                None => Err(ValidationError::MissingSslKeyPath {
+                    ssl_key_path: String::new(),
+                }),
+            }?;
+        }
+
+        Ok(Self {
+            enabled: config.enabled,
+            bind_address: config.bind_address,
+            ssl_enabled: config.ssl_enabled,
+            ssl_cert_path: config.ssl_cert_path,
+            ssl_key_path: config.ssl_key_path,
+        })
+    }
+}
+
+impl From<Config> for HttpTracker {
+    fn from(config: Config) -> Self {
+        Self {
+            enabled: config.enabled,
+            bind_address: config.bind_address,
+            ssl_enabled: config.ssl_enabled,
+            ssl_cert_path: config.ssl_cert_path,
+            ssl_key_path: config.ssl_key_path,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    mod when_ssl_is_enabled {
+        use crate::http_tracker::{Config, ValidationError};
+        use crate::HttpTracker;
+
+        #[test]
+        fn it_should_return_an_error_when_ssl_is_enabled_but_the_cert_path_is_not_provided() {
+            let plain_config = HttpTracker {
+                enabled: true,
+                bind_address: "127.0.0.1:7070".to_string(),
+                ssl_enabled: true,
+                ssl_cert_path: None,
+                ssl_key_path: Some("./localhost.key".to_string()),
+            };
+
+            assert_eq!(
+                Config::try_from(plain_config),
+                Err(ValidationError::MissingSslCertPath {
+                    ssl_cert_path: String::new()
+                })
+            );
+        }
+
+        #[test]
+        fn it_should_return_an_error_when_ssl_is_enabled_but_the_cert_path_is_empty() {
+            let plain_config = HttpTracker {
+                enabled: true,
+                bind_address: "127.0.0.1:7070".to_string(),
+                ssl_enabled: true,
+                ssl_cert_path: Some(String::new()),
+                ssl_key_path: Some("./localhost.key".to_string()),
+            };
+
+            assert_eq!(
+                Config::try_from(plain_config),
+                Err(ValidationError::MissingSslCertPath {
+                    ssl_cert_path: String::new()
+                })
+            );
+        }
+
+        #[test]
+        fn it_should_return_an_error_when_ssl_is_enabled_but_the_key_path_is_not_provided() {
+            let plain_config = HttpTracker {
+                enabled: true,
+                bind_address: "127.0.0.1:7070".to_string(),
+                ssl_enabled: true,
+                ssl_cert_path: Some("./localhost.crt".to_string()),
+                ssl_key_path: None,
+            };
+
+            assert_eq!(
+                Config::try_from(plain_config),
+                Err(ValidationError::MissingSslKeyPath {
+                    ssl_key_path: String::new()
+                })
+            );
+        }
+
+        #[test]
+        fn it_should_return_an_error_when_ssl_is_enabled_but_the_key_path_is_empty() {
+            let plain_config = HttpTracker {
+                enabled: true,
+                bind_address: "127.0.0.1:7070".to_string(),
+                ssl_enabled: true,
+                ssl_cert_path: Some("./localhost.crt".to_string()),
+                ssl_key_path: Some(String::new()),
+            };
+
+            assert_eq!(
+                Config::try_from(plain_config),
+                Err(ValidationError::MissingSslKeyPath {
+                    ssl_key_path: String::new()
+                })
+            );
+        }
+    }
+}

packages/configuration/src/lib.rs

@@ -229,6 +229,10 @@
 //! [health_check_api]
 //! bind_address = "127.0.0.1:1313"
 //!```
+pub mod http_tracker;
+pub mod tracker_api;
+pub mod udp_tracker;
+
 use std::collections::HashMap;
 use std::net::IpAddr;
 use std::str::FromStr;
@@ -261,16 +265,7 @@ pub struct Info {
 }
 
 impl Info {
-    /// Build Configuration Info
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use torrust_tracker_configuration::Info;
-    ///
-    /// let result = Info::new(env_var_config, env_var_path_config, default_path_config, env_var_api_admin_token);
-    /// assert_eq!(result, );
-    /// ```
+    /// Build Configuration Info.
     ///
     /// # Errors
     ///

packages/configuration/src/tracker_api.rs

@@ -0,0 +1 @@
+

packages/configuration/src/udp_tracker.rs

@@ -0,0 +1 @@
+

src/app.rs

@@ -75,21 +75,26 @@ pub async fn start(config: &Configuration, tracker: Arc<core::Tracker>) -> Vec<J
     }
 
     // Start the HTTP blocks
-    for http_tracker_config in &config.http_trackers {
-        if !http_tracker_config.enabled {
-            continue;
-        }
+    for plain_http_tracker_config in &config.http_trackers {
+        match torrust_tracker_configuration::http_tracker::Config::try_from(plain_http_tracker_config.clone()) {
+            Ok(http_tracker_config) => {
+                if !http_tracker_config.is_enabled() {
+                    continue;
+                }
 
-        if let Some(job) = http_tracker::start_job(
-            http_tracker_config,
-            tracker.clone(),
-            registar.give_form(),
-            servers::http::Version::V1,
-        )
-        .await
-        {
-            jobs.push(job);
-        };
+                if let Some(job) = http_tracker::start_job(
+                    &http_tracker_config.into(),
+                    tracker.clone(),
+                    registar.give_form(),
+                    servers::http::Version::V1,
+                )
+                .await
+                {
+                    jobs.push(job);
+                };
+            }
+            Err(err) => panic!("Invalid HTTP Tracker configuration: {err}"),
+        }
     }
 
     // Start HTTP API

tests/servers/api/v1/contract/configuration.rs

@@ -1,4 +1,3 @@
 pub mod authentication;
-pub mod configuration;
 pub mod context;
 pub mod fixtures;