refactor: [torrust#634] extract funtions

Author: josecelano

src/e2e/docker.rs

@@ -1,10 +1,12 @@
+//! Docker command wrapper.
 use std::io;
 use std::process::{Command, Output};
 use std::thread::sleep;
 use std::time::{Duration, Instant};
 
 use log::debug;
 
+/// Docker command wrapper.
 pub struct Docker {}
 
 pub struct RunningContainer {

src/e2e/logs.rs

@@ -0,0 +1,114 @@
+//! Utilities to parse Torrust Tracker logs.
+use serde::{Deserialize, Serialize};
+
+const UDP_TRACKER_PATTERN: &str = "[UDP Tracker][INFO] Starting on: udp://";
+const HTTP_TRACKER_PATTERN: &str = "[HTTP Tracker][INFO] Starting on: ";
+const HEALTH_CHECK_PATTERN: &str = "[Health Check API][INFO] Starting on: ";
+
+#[derive(Serialize, Deserialize, Debug, Default)]
+pub struct RunningServices {
+    pub udp_trackers: Vec<String>,
+    pub http_trackers: Vec<String>,
+    pub health_checks: Vec<String>,
+}
+
+impl RunningServices {
+    /// It parses the tracker logs to extract the running services.
+    ///
+    /// For example, from this logs:
+    ///
+    /// ```text
+    /// Loading default configuration file: `./share/default/config/tracker.development.sqlite3.toml` ...
+    /// 2024-01-24T16:36:14.614898789+00:00 [torrust_tracker::bootstrap::logging][INFO] logging initialized.
+    /// 2024-01-24T16:36:14.615586025+00:00 [UDP Tracker][INFO] Starting on: udp://0.0.0.0:6969
+    /// 2024-01-24T16:36:14.615623705+00:00 [torrust_tracker::bootstrap::jobs][INFO] TLS not enabled
+    /// 2024-01-24T16:36:14.615694484+00:00 [HTTP Tracker][INFO] Starting on: http://0.0.0.0:7070
+    /// 2024-01-24T16:36:14.615710534+00:00 [HTTP Tracker][INFO] Started on: http://0.0.0.0:7070
+    /// 2024-01-24T16:36:14.615716574+00:00 [torrust_tracker::bootstrap::jobs][INFO] TLS not enabled
+    /// 2024-01-24T16:36:14.615764904+00:00 [API][INFO] Starting on http://127.0.0.1:1212
+    /// 2024-01-24T16:36:14.615767264+00:00 [API][INFO] Started on http://127.0.0.1:1212
+    /// 2024-01-24T16:36:14.615777574+00:00 [Health Check API][INFO] Starting on: http://127.0.0.1:1313
+    /// 2024-01-24T16:36:14.615791124+00:00 [Health Check API][INFO] Started on: http://127.0.0.1:1313
+    /// ```
+    ///
+    /// It would extract theses services:
+    ///
+    /// ```json
+    /// {
+    ///   "udp_trackers": [
+    ///     "127.0.0.1:6969"
+    ///    ],
+    ///    "http_trackers": [
+    ///      "http://127.0.0.1:7070"
+    ///    ],
+    ///    "health_checks": [
+    ///      "http://127.0.0.1:1313/health_check"
+    ///    ]
+    /// }
+    /// ```
+    #[must_use]
+    pub fn parse_from_logs(logs: &str) -> Self {
+        let mut udp_trackers: Vec<String> = Vec::new();
+        let mut http_trackers: Vec<String> = Vec::new();
+        let mut health_checks: Vec<String> = Vec::new();
+
+        for line in logs.lines() {
+            if let Some(address) = Self::extract_address_if_matches(line, UDP_TRACKER_PATTERN) {
+                udp_trackers.push(address);
+            } else if let Some(address) = Self::extract_address_if_matches(line, HTTP_TRACKER_PATTERN) {
+                http_trackers.push(address);
+            } else if let Some(address) = Self::extract_address_if_matches(line, HEALTH_CHECK_PATTERN) {
+                health_checks.push(format!("{address}/health_check"));
+            }
+        }
+
+        Self {
+            udp_trackers,
+            http_trackers,
+            health_checks,
+        }
+    }
+
+    fn extract_address_if_matches(line: &str, pattern: &str) -> Option<String> {
+        line.find(pattern)
+            .map(|start| Self::replace_wildcard_ip_with_localhost(line[start + pattern.len()..].trim()))
+    }
+
+    fn replace_wildcard_ip_with_localhost(address: &str) -> String {
+        address.replace("0.0.0.0", "127.0.0.1")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_should_parse_from_logs_with_valid_logs() {
+        let logs = "\
+            [UDP Tracker][INFO] Starting on: udp://0.0.0.0:8080\n\
+            [HTTP Tracker][INFO] Starting on: 0.0.0.0:9090\n\
+            [Health Check API][INFO] Starting on: 0.0.0.0:10010";
+        let running_services = RunningServices::parse_from_logs(logs);
+
+        assert_eq!(running_services.udp_trackers, vec!["127.0.0.1:8080"]);
+        assert_eq!(running_services.http_trackers, vec!["127.0.0.1:9090"]);
+        assert_eq!(running_services.health_checks, vec!["127.0.0.1:10010/health_check"]);
+    }
+
+    #[test]
+    fn it_should_ignore_logs_with_no_matching_lines() {
+        let logs = "[Other Service][INFO] Starting on: 0.0.0.0:7070";
+        let running_services = RunningServices::parse_from_logs(logs);
+
+        assert!(running_services.udp_trackers.is_empty());
+        assert!(running_services.http_trackers.is_empty());
+        assert!(running_services.health_checks.is_empty());
+    }
+
+    #[test]
+    fn it_should_replace_wildcard_ip_with_localhost() {
+        let address = "0.0.0.0:8080";
+        assert_eq!(RunningServices::replace_wildcard_ip_with_localhost(address), "127.0.0.1:8080");
+    }
+}

src/e2e/logs_parser.rs

@@ -1,4 +1,4 @@
 pub mod docker;
-pub mod logs;
+pub mod logs_parser;
 pub mod runner;
 pub mod temp_dir;

src/e2e/mod.rs

@@ -9,102 +9,68 @@ use log::{debug, info, LevelFilter};
 use rand::distributions::Alphanumeric;
 use rand::Rng;
 
+use super::docker::RunningContainer;
 use crate::e2e::docker::Docker;
-use crate::e2e::logs::RunningServices;
+use crate::e2e::logs_parser::RunningServices;
 use crate::e2e::temp_dir::Handler;
 
 pub const NUMBER_OF_ARGUMENTS: usize = 2;
+const CONTAINER_TAG: &str = "torrust-tracker:local";
+const TRACKER_CHECKER_CONFIG_FILE: &str = "tracker_checker.json";
 
+pub struct Arguments {
+    pub tracker_config_path: String,
+}
+
+/// Script to run E2E tests.
+///
 /// # Panics
 ///
 /// Will panic if it can't not perform any of the operations.
 pub fn run() {
-    // todo: const
-    let container_tag: &str = "torrust-tracker:local";
-    let tracker_checker_config_file = "tracker_checker.json";
-
-    setup_logging(LevelFilter::Info);
+    setup_runner_logging(LevelFilter::Info);
 
     let args = parse_arguments();
 
-    // Setup tracker configuration
-    info!("Reading tracker configuration from file: {} ...", args.tracker_config_path);
-    let tracker_config = read_tracker_config(&args.tracker_config_path);
+    let tracker_config = load_tracker_configuration(&args.tracker_config_path);
 
-    // Build tracker container image
-    Docker::build("./Containerfile", container_tag).expect("A tracker local docker image should be built");
+    build_tracker_container_image(CONTAINER_TAG);
 
-    // Create temp dir
-    info!(
-        "Current dir: {:?}",
-        env::current_dir().expect("It should return the current dir")
-    );
-    let temp_dir_handler = Handler::new().expect("A temp dir should be created");
-    info!("Temp dir created: {:?}", temp_dir_handler.temp_dir);
+    let temp_dir = create_temp_dir();
 
-    // Run the tracker container
     let container_name = generate_random_container_name("tracker_");
 
     // code-review: if we want to use port 0 we don't know which ports we have to open.
     // Besides, if we don't use port 0 we should get the port numbers from the tracker configuration.
     // We could not use docker, but the intention was to create E2E tests including containerization.
-    info!("Running docker tracker image: {container_name} ...");
     let env_vars = [("TORRUST_TRACKER_CONFIG".to_string(), tracker_config.to_string())];
     let ports = [
         "6969:6969/udp".to_string(),
         "7070:7070/tcp".to_string(),
         "1212:1212/tcp".to_string(),
         "1313:1313/tcp".to_string(),
     ];
-    let container =
-        Docker::run(container_tag, &container_name, &env_vars, &ports).expect("A tracker local docker image should be running");
-
-    info!("Waiting for the container {container_name} to be healthy ...");
-    let is_healthy = Docker::wait_until_is_healthy(&container_name, Duration::from_secs(10));
-
-    assert!(is_healthy, "Unhealthy tracker container: {container_name}");
 
-    info!("Container {container_name} is healthy ...");
+    let container = run_tracker_container(&container_name, &env_vars, &ports);
 
-    // Extract running services from container logs
+    let running_services = parse_running_services_from_logs(&container);
 
-    let logs = Docker::logs(&container_name).expect("Logs should be captured from running container");
-
-    debug!("Logs after starting the container:\n{logs}");
+    let tracker_checker_config =
+        serde_json::to_string_pretty(&running_services).expect("Running services should be serialized into JSON");
 
-    let mut config = RunningServices::default();
-    config.extract_from_logs(&logs);
+    let mut tracker_checker_config_path = PathBuf::from(&temp_dir.temp_dir.path());
+    tracker_checker_config_path.push(TRACKER_CHECKER_CONFIG_FILE);
 
-    let json = serde_json::to_string_pretty(&config).expect("Running services should be serialized into JSON");
+    write_tracker_checker_config(&tracker_checker_config_path, &tracker_checker_config);
 
-    // Write tracker_checker configuration file
-
-    let mut absolute_tracker_checker_config_path = PathBuf::from(&temp_dir_handler.temp_dir.path());
-    absolute_tracker_checker_config_path.push(tracker_checker_config_file);
-
-    let mut file = File::create(absolute_tracker_checker_config_path.clone()).expect("Tracker checker config file to be created");
-    file.write_all(json.as_bytes())
-        .expect("Tracker checker config file to be written");
-    info!(
-        "Tracker checker configuration file: {:?} \n{json}",
-        absolute_tracker_checker_config_path
-    );
-
-    // Run the tracker_checker
-
-    info!(
-        "Running tacker checker: cargo --bin tracker_checker {}",
-        absolute_tracker_checker_config_path.display()
-    );
-
-    run_tracker_checker(&absolute_tracker_checker_config_path).expect("Tracker checker should check running services");
-
-    // End: container will be removed automatically when the `RunningContainer` is dropped.
+    run_tracker_checker(&tracker_checker_config_path).expect("Tracker checker should check running services");
 
     info!("Running container `{}` will be automatically removed", container.name);
+
+    // Container will be removed automatically when the `RunningContainer` is dropped.
 }
 
-fn setup_logging(level: LevelFilter) {
+fn setup_runner_logging(level: LevelFilter) {
     if let Err(_err) = fern::Dispatch::new()
         .format(|out, message, record| {
             out.finish(format_args!(
@@ -125,10 +91,6 @@ fn setup_logging(level: LevelFilter) {
     debug!("logging initialized.");
 }
 
-pub struct Arguments {
-    pub tracker_config_path: String,
-}
-
 fn parse_arguments() -> Arguments {
     let args: Vec<String> = std::env::args().collect();
 
@@ -145,9 +107,31 @@ fn parse_arguments() -> Arguments {
     }
 }
 
-fn read_tracker_config(tracker_config_path: &str) -> String {
-    std::fs::read_to_string(tracker_config_path)
-        .unwrap_or_else(|_| panic!("Can't read tracker config file {tracker_config_path}"))
+fn load_tracker_configuration(tracker_config_path: &str) -> String {
+    info!("Reading tracker configuration from file: {} ...", tracker_config_path);
+    read_file(tracker_config_path)
+}
+
+fn read_file(path: &str) -> String {
+    std::fs::read_to_string(path).unwrap_or_else(|_| panic!("Can't read file {path}"))
+}
+
+fn build_tracker_container_image(tag: &str) {
+    info!("Building tracker container image with tag: {} ...", tag);
+    Docker::build("./Containerfile", tag).expect("A tracker local docker image should be built");
+}
+
+fn create_temp_dir() -> Handler {
+    debug!(
+        "Current dir: {:?}",
+        env::current_dir().expect("It should return the current dir")
+    );
+
+    let temp_dir_handler = Handler::new().expect("A temp dir should be created");
+
+    info!("Temp dir created: {:?}", temp_dir_handler.temp_dir);
+
+    temp_dir_handler
 }
 
 fn generate_random_container_name(prefix: &str) -> String {
@@ -160,6 +144,40 @@ fn generate_random_container_name(prefix: &str) -> String {
     format!("{prefix}{rand_string}")
 }
 
+fn run_tracker_container(container_name: &str, env_vars: &[(String, String)], ports: &[String]) -> RunningContainer {
+    info!("Running docker tracker image: {container_name} ...");
+
+    let container =
+        Docker::run(CONTAINER_TAG, container_name, env_vars, ports).expect("A tracker local docker image should be running");
+
+    info!("Waiting for the container {container_name} to be healthy ...");
+
+    let is_healthy = Docker::wait_until_is_healthy(container_name, Duration::from_secs(10));
+
+    assert!(is_healthy, "Unhealthy tracker container: {container_name}");
+
+    debug!("Container {container_name} is healthy ...");
+
+    container
+}
+
+fn parse_running_services_from_logs(container: &RunningContainer) -> RunningServices {
+    let logs = Docker::logs(&container.name).expect("Logs should be captured from running container");
+
+    debug!("Logs after starting the container:\n{logs}");
+
+    RunningServices::parse_from_logs(&logs)
+}
+
+fn write_tracker_checker_config(config_file_path: &Path, config: &str) {
+    let mut file = File::create(config_file_path).expect("Tracker checker config file to be created");
+
+    file.write_all(config.as_bytes())
+        .expect("Tracker checker config file to be written");
+
+    info!("Tracker checker configuration file: {:?} \n{config}", config_file_path);
+}
+
 /// Runs the tracker checker
 ///
 /// ```text
@@ -174,6 +192,11 @@ fn generate_random_container_name(prefix: &str) -> String {
 ///
 /// Will panic if the config path is not a valid string.
 pub fn run_tracker_checker(config_path: &Path) -> io::Result<()> {
+    info!(
+        "Running tacker checker: cargo --bin tracker_checker {}",
+        config_path.display()
+    );
+
     let path = config_path.to_str().expect("The path should be a valid string");
 
     let status = Command::new("cargo")