Merge #237: feat: [#236] make Docker Compose tracker ports dynamic

95d5e13 refactor: [#236] fix clippy too_many_arguments error with TrackerPorts struct (Jose Celano)
150f382 test: [#236] verify dynamic ports are rendered in docker-compose.yml (Jose Celano)
b902262 feat: [#236] make Docker Compose ports dynamic using Tera variables (Jose Celano)
5909c0b feat: [#236] extend DockerComposeContext with tracker port fields (Jose Celano)

Pull request description:

  ## Description

  This PR implements dynamic tracker ports in Docker Compose templates, replacing hardcoded port values with Tera template variables extracted from the tracker configuration.

  Closes #236

  ## Changes

  ### Core Implementation
  - **Extended `DockerComposeContext`** with tracker port fields (udp_tracker_ports, http_tracker_ports, http_api_port)
  - **Created `TrackerPorts` struct** to group port parameters and resolve clippy `too_many_arguments` warning
  - **Implemented `extract_tracker_ports()`** helper to extract ports from `TrackerConfig` domain model
  - **Updated `docker-compose.yml.tera`** template with Tera loops for dynamic port rendering

  ### Files Modified
  - `src/infrastructure/templating/docker_compose/template/wrappers/docker_compose/context.rs` - Added TrackerPorts struct and port fields
  - `src/application/steps/rendering/docker_compose_templates.rs` - Implemented port extraction logic
  - `templates/docker-compose/docker-compose.yml.tera` - Replaced hardcoded ports with dynamic Tera variables
  - Updated 27+ test call sites across context.rs, template.rs, docker_compose.rs, project_generator.rs

  ## Testing

  ### Automated Tests ✅
  - **1473 unit tests** pass (11.95s)
  - **8 E2E integration tests** pass
  - **371 doc tests** pass (22.20s)
  - All linters pass (markdown, YAML, TOML, clippy, rustfmt, shellcheck, cspell)
  - Pre-commit validation: 6/6 steps pass (4m 58s)

  ### Manual E2E Test ✅
  Successfully completed full deployment workflow with custom port configuration.

  **Test Configuration:**
  - 3 UDP Tracker Ports: 8080, 8081, 8082 (instead of default 6868, 6969)
  - 2 HTTP Tracker Ports: 9090, 9091 (instead of default 7070)
  - 1 HTTP API Port: 3030 (instead of default 1212)

  **Test Results:**

  1. ✅ Environment created successfully
  2. ✅ Infrastructure provisioned with LXD
  3. ✅ Instance configured with Ansible
  4. ✅ docker-compose.yml generated with correct dynamic ports:
     ```yaml
     ports:
       # UDP Tracker Ports (dynamically configured)
       - 8080:8080/udp
       - 8081:8081/udp
       - 8082:8082/udp
       # HTTP Tracker Ports (dynamically configured)
       - 9090:9090
       - 9091:9091
       # HTTP API Port (dynamically configured)
       - 3030:3030
     ```
  5. ✅ Tracker started successfully
  6. ✅ Container verified running with correct port mappings:
     ```
     0.0.0.0:8080-8082->8080-8082/udp
     0.0.0.0:9090-9091->9090-9091/tcp
     0.0.0.0:3030->3030/tcp
     ```
  7. ✅ Services verified accessible from outside VM (IP: 10.140.190.152):
     - HTTP API: `curl http://10.140.190.152:3030/api/health_check` → `{"status":"Ok"}`
     - HTTP Tracker 1: `curl http://10.140.190.152:9090/announce` → Responding
     - HTTP Tracker 2: `curl http://10.140.190.152:9091/announce` → Responding
  8. ✅ Environment destroyed cleanly

  **Key Achievements:**
  - ✅ Multiple UDP trackers (3 ports) working simultaneously
  - ✅ Multiple HTTP trackers (2 ports) working simultaneously
  - ✅ Custom API port responding correctly
  - ✅ All services accessible on configured custom ports

  ## Implementation Details

  **Before (Hardcoded):**
  ```yaml
  ports:
    - "6868:6868/udp"
    - "6969:6969/udp"
    - "7070:7070"
    - "1212:1212"
  ```

  **After (Dynamic):**
  ```yaml
  ports:
    {% for port in udp_tracker_ports %}
    - "{{ port }}:{{ port }}/udp"
    {% endfor %}
    {% for port in http_tracker_ports %}
    - "{{ port }}:{{ port }}"
    {% endfor %}
    - "{{ http_api_port }}:{{ http_api_port }}"
  ```

  ## Architecture

  The implementation follows the existing pattern established by `AnsibleVariablesContext`:
  1. Port extraction in `RenderDockerComposeTemplatesStep`
  2. Domain model (`TrackerConfig`) as source of truth
  3. Infrastructure layer handles serialization
  4. Tera template rendering with dynamic loops

  ## Commits
  - docs: [#236] add issue specification for dynamic tracker ports
  - feat: [#236] extend DockerComposeContext with tracker port fields
  - feat: [#236] make Docker Compose ports dynamic using Tera variables
  - test: [#236] verify dynamic ports are rendered in docker-compose.yml
  - refactor: [#236] fix clippy too_many_arguments error with TrackerPorts struct

  ## Checklist
  - [x] Code follows DDD layer placement guidelines
  - [x] All automated tests pass
  - [x] Pre-commit validation passes
  - [x] Conventional commit format used
  - [x] Issue number referenced in commits
  - [x] Manual E2E test completed
  - [x] Feature verified working in real deployment

ACKs for top commit:
  josecelano:
    ACK 95d5e13

Tree-SHA512: bf83696b8be104f2929b82245028c6bc12a0ba4b00f2bda21898bb1571a8dcf7ce088bcdc1d47eccfa2e066c6df0f2266b72640a20ef2a6b864d4107f3c85bed

Author: josecelano

src/application/steps/rendering/docker_compose_templates.rs

@@ -31,8 +31,10 @@ use tracing::{info, instrument};
 
 use crate::domain::environment::Environment;
 use crate::domain::template::TemplateManager;
-use crate::domain::tracker::DatabaseConfig;
-use crate::infrastructure::templating::docker_compose::template::wrappers::docker_compose::DockerComposeContext;
+use crate::domain::tracker::{DatabaseConfig, TrackerConfig};
+use crate::infrastructure::templating::docker_compose::template::wrappers::docker_compose::{
+    DockerComposeContext, TrackerPorts,
+};
 use crate::infrastructure::templating::docker_compose::template::wrappers::env::EnvContext;
 use crate::infrastructure::templating::docker_compose::{
     DockerComposeProjectGenerator, DockerComposeProjectGeneratorError,
@@ -70,6 +72,30 @@ impl<S> RenderDockerComposeTemplatesStep<S> {
         }
     }
 
+    /// Extract port numbers from tracker configuration
+    ///
+    /// Returns a tuple of (`udp_ports`, `http_ports`, `api_port`)
+    fn extract_tracker_ports(tracker_config: &TrackerConfig) -> (Vec<u16>, Vec<u16>, u16) {
+        // Extract UDP tracker ports
+        let udp_ports: Vec<u16> = tracker_config
+            .udp_trackers
+            .iter()
+            .map(|tracker| tracker.bind_address.port())
+            .collect();
+
+        // Extract HTTP tracker ports
+        let http_ports: Vec<u16> = tracker_config
+            .http_trackers
+            .iter()
+            .map(|tracker| tracker.bind_address.port())
+            .collect();
+
+        // Extract HTTP API port
+        let api_port = tracker_config.http_api.bind_address.port();
+
+        (udp_ports, http_ports, api_port)
+    }
+
     /// Execute the template rendering step
     ///
     /// This will render Docker Compose templates to the build directory.
@@ -113,12 +139,23 @@ impl<S> RenderDockerComposeTemplatesStep<S> {
             .admin_token
             .clone();
 
+        // Extract tracker ports from configuration
+        let tracker_config = &self.environment.context().user_inputs.tracker;
+        let (udp_tracker_ports, http_tracker_ports, http_api_port) =
+            Self::extract_tracker_ports(tracker_config);
+
+        let ports = TrackerPorts {
+            udp_tracker_ports,
+            http_tracker_ports,
+            http_api_port,
+        };
+
         // Create contexts based on database configuration
         let database_config = &self.environment.context().user_inputs.tracker.core.database;
         let (env_context, docker_compose_context) = match database_config {
             DatabaseConfig::Sqlite { .. } => {
                 let env_context = EnvContext::new(admin_token);
-                let docker_compose_context = DockerComposeContext::new_sqlite();
+                let docker_compose_context = DockerComposeContext::new_sqlite(ports);
                 (env_context, docker_compose_context)
             }
             DatabaseConfig::Mysql {
@@ -145,6 +182,7 @@ impl<S> RenderDockerComposeTemplatesStep<S> {
                     username.clone(),
                     password.clone(),
                     *port,
+                    ports,
                 );
 
                 (env_context, docker_compose_context)
@@ -248,5 +286,25 @@ mod tests {
         // Verify it contains expected content from embedded template
         assert!(output_content.contains("torrust/tracker"));
         assert!(output_content.contains("./storage/tracker/lib:/var/lib/torrust/tracker"));
+
+        // Verify dynamic ports are rendered (default TrackerConfig has 6969 UDP, 7070 HTTP, 1212 API)
+        assert!(
+            output_content.contains("6969:6969/udp"),
+            "Should contain UDP tracker port 6969"
+        );
+        assert!(
+            output_content.contains("7070:7070"),
+            "Should contain HTTP tracker port 7070"
+        );
+        assert!(
+            output_content.contains("1212:1212"),
+            "Should contain HTTP API port 1212"
+        );
+
+        // Verify hardcoded ports are NOT present
+        assert!(
+            !output_content.contains("6868:6868"),
+            "Should not contain hardcoded UDP port 6868"
+        );
     }
 }

src/infrastructure/templating/docker_compose/template/renderer/docker_compose.rs

@@ -188,7 +188,9 @@ mod tests {
     use super::*;
     use tempfile::TempDir;
 
-    use crate::infrastructure::templating::docker_compose::template::wrappers::docker_compose::DockerComposeContext;
+    use crate::infrastructure::templating::docker_compose::template::wrappers::docker_compose::{
+        DockerComposeContext, TrackerPorts,
+    };
 
     #[test]
     fn it_should_create_renderer_with_template_manager() {
@@ -212,12 +214,18 @@ mod tests {
         let temp_dir = TempDir::new().unwrap();
         let template_manager = Arc::new(TemplateManager::new(temp_dir.path()));
 
+        let ports = TrackerPorts {
+            udp_tracker_ports: vec![6868, 6969],
+            http_tracker_ports: vec![7070],
+            http_api_port: 1212,
+        };
         let mysql_context = DockerComposeContext::new_mysql(
             "rootpass123".to_string(),
             "tracker_db".to_string(),
             "tracker_user".to_string(),
             "userpass123".to_string(),
             3306,
+            ports,
         );
 
         let renderer = DockerComposeRenderer::new(template_manager);
@@ -294,7 +302,12 @@ mod tests {
         let temp_dir = TempDir::new().unwrap();
         let template_manager = Arc::new(TemplateManager::new(temp_dir.path()));
 
-        let sqlite_context = DockerComposeContext::new_sqlite();
+        let ports = TrackerPorts {
+            udp_tracker_ports: vec![6868, 6969],
+            http_tracker_ports: vec![7070],
+            http_api_port: 1212,
+        };
+        let sqlite_context = DockerComposeContext::new_sqlite(ports);
 
         let renderer = DockerComposeRenderer::new(template_manager);
         let output_dir = TempDir::new().unwrap();

src/infrastructure/templating/docker_compose/template/renderer/project_generator.rs

@@ -185,6 +185,7 @@ mod tests {
     use tempfile::TempDir;
 
     use super::*;
+    use crate::infrastructure::templating::docker_compose::template::wrappers::docker_compose::TrackerPorts;
     use crate::infrastructure::templating::docker_compose::DOCKER_COMPOSE_SUBFOLDER;
 
     /// Creates a `TemplateManager` that uses the embedded templates
@@ -205,7 +206,13 @@ mod tests {
 
     /// Helper function to create a test docker-compose context with `SQLite`
     fn create_test_docker_compose_context_sqlite() -> DockerComposeContext {
-        DockerComposeContext::new_sqlite()
+        // Use default test ports (matching TrackerConfig::default())
+        let ports = TrackerPorts {
+            udp_tracker_ports: vec![6969],
+            http_tracker_ports: vec![7070],
+            http_api_port: 1212,
+        };
+        DockerComposeContext::new_sqlite(ports)
     }
 
     #[tokio::test]