Struct TrackerConfig 

pub struct TrackerConfig { /* private fields */ }

Tracker deployment configuration

This structure mirrors the real tracker configuration but only includes user-configurable fields that are exposed via the environment.json file.

Examples

use torrust_tracker_deployer_lib::domain::tracker::{
    TrackerConfig, TrackerCoreConfig, DatabaseConfig, SqliteConfig,
    UdpTrackerConfig, HttpTrackerConfig, HttpApiConfig, HealthCheckApiConfig
};

let tracker_config = TrackerConfig::new(
    TrackerCoreConfig::new(
        DatabaseConfig::Sqlite(SqliteConfig::new("tracker.db").unwrap()),
        false,
    ),
    vec![UdpTrackerConfig::new("0.0.0.0:6969".parse().unwrap(), None).unwrap()],
    vec![HttpTrackerConfig::new("0.0.0.0:7070".parse().unwrap(), None, false).unwrap()],
    HttpApiConfig::new(
        "0.0.0.0:1212".parse().unwrap(),
        "MyAccessToken".to_string().into(),
        None,
        false,
    ).expect("valid config"),
    HealthCheckApiConfig::new(
        "127.0.0.1:1313".parse().unwrap(),
        None,
        false,
    ).expect("valid config"),
).expect("valid config");

Implementations

impl TrackerConfig

pub fn new( core: TrackerCoreConfig, udp_trackers: Vec<UdpTrackerConfig>, http_trackers: Vec<HttpTrackerConfig>, http_api: HttpApiConfig, health_check_api: HealthCheckApiConfig, ) -> Result<Self, TrackerConfigError>

Creates a new TrackerConfig with validated aggregate invariants.

This constructor validates that no socket address conflicts exist (multiple services binding to the same IP:port:protocol combination).

Errors

Returns TrackerConfigError::DuplicateSocketAddress if multiple services using the same protocol attempt to bind to the same socket address.

Note

Individual component validation (port != 0, TLS requires domain, localhost cannot use TLS) is enforced by the child config types at their construction time. This constructor only validates aggregate-level invariants.

Examples

use torrust_tracker_deployer_lib::domain::tracker::{
    TrackerConfig, TrackerCoreConfig, DatabaseConfig, SqliteConfig,
    UdpTrackerConfig, HttpTrackerConfig, HttpApiConfig, HealthCheckApiConfig
};

let config = TrackerConfig::new(
    TrackerCoreConfig::new(
        DatabaseConfig::Sqlite(SqliteConfig::new("tracker.db").unwrap()),
        false,
    ),
    vec![UdpTrackerConfig::new("0.0.0.0:6969".parse().unwrap(), None).unwrap()],
    vec![HttpTrackerConfig::new("0.0.0.0:7070".parse().unwrap(), None, false).unwrap()],
    HttpApiConfig::new(
        "0.0.0.0:1212".parse().unwrap(),
        "MyAccessToken".to_string().into(),
        None,
        false,
    ).unwrap(),
    HealthCheckApiConfig::new(
        "127.0.0.1:1313".parse().unwrap(),
        None,
        false,
    ).unwrap(),
).expect("valid config");

pub fn core(&self) -> &TrackerCoreConfig

Returns the core tracker configuration.

pub fn udp_trackers(&self) -> &[UdpTrackerConfig]

Returns the UDP tracker configurations.

pub fn http_trackers(&self) -> &[HttpTrackerConfig]

Returns the HTTP tracker configurations.

pub fn http_api(&self) -> &HttpApiConfig

Returns the HTTP API configuration.

pub fn health_check_api(&self) -> &HealthCheckApiConfig

Returns the Health Check API configuration.

pub fn uses_mysql(&self) -> bool

Returns whether the tracker is configured to use MySQL database.

This is useful for determining if MySQL-related infrastructure (like storage directories) needs to be created.

Examples

use torrust_tracker_deployer_lib::domain::tracker::{
    TrackerConfig, TrackerCoreConfig, DatabaseConfig, SqliteConfig,
    UdpTrackerConfig, HttpTrackerConfig, HttpApiConfig, HealthCheckApiConfig
};

let tracker_config = TrackerConfig::new(
    TrackerCoreConfig::new(
        DatabaseConfig::Sqlite(SqliteConfig::new("tracker.db").unwrap()),
        false,
    ),
    vec![UdpTrackerConfig::new("0.0.0.0:6969".parse().unwrap(), None).unwrap()],
    vec![HttpTrackerConfig::new("0.0.0.0:7070".parse().unwrap(), None, false).unwrap()],
    HttpApiConfig::new(
        "0.0.0.0:1212".parse().unwrap(),
        "MyAccessToken".to_string().into(),
        None,
        false,
    ).expect("valid config"),
    HealthCheckApiConfig::new(
        "127.0.0.1:1313".parse().unwrap(),
        None,
        false,
    ).expect("valid config"),
).expect("valid config");

// SQLite config -> not MySQL
assert!(!tracker_config.uses_mysql());

pub fn docker_image() -> DockerImage

Returns the Docker image used for the tracker service.

This is a pinned constant — not user-configurable.

Examples

use torrust_tracker_deployer_lib::domain::tracker::TrackerConfig;

let image = TrackerConfig::docker_image();
assert_eq!(image.full_reference(), "torrust/tracker:develop");

pub fn http_api_tls_domain(&self) -> Option<&str>

Returns the HTTP API TLS domain if configured

pub fn http_api_port(&self) -> u16

Returns the HTTP API port number

pub fn health_check_api_tls_domain(&self) -> Option<&str>

Returns the Health Check API TLS domain if configured

pub fn health_check_api_port(&self) -> u16

Returns the Health Check API port number

pub fn http_trackers_with_tls(&self) -> Vec<(&str, u16)>

Returns HTTP trackers that have TLS proxy enabled

Returns a vector of tuples containing (domain, port) for each HTTP tracker that has use_tls_proxy: true and a domain configured.

pub fn any_http_tracker_uses_tls_proxy(&self) -> bool

Returns true if any HTTP tracker has use_tls_proxy: true

This is used to determine if the tracker’s global on_reverse_proxy setting should be enabled in the tracker configuration template.

pub fn has_any_tls_configured(&self) -> bool

Returns true if any service has TLS proxy configured

Checks if at least one of the following services has TLS enabled:

• HTTP API (use_tls_proxy: true)
• Any HTTP tracker (use_tls_proxy: true)
• Health Check API (use_tls_proxy: true)

This is used for cross-service validation to ensure that when the HTTPS section is defined, at least one service actually uses TLS.

Trait Implementations

impl Clone for TrackerConfig

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TrackerConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TrackerConfig

fn default() -> Self

Returns a default tracker configuration suitable for development and testing

Default Values

• Database: SQLite with filename “tracker.db”
• Mode: Public tracker (private = false)
• UDP trackers: One instance on port 6969
• HTTP trackers: One instance on port 7070
• HTTP API: Bind address 0.0.0.0:1212
• Admin token: MyAccessToken

impl<'de> Deserialize<'de> for TrackerConfig

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl NetworkDerivation for TrackerConfig

fn derive_networks(&self, enabled_services: &EnabledServices) -> Vec<Network>

Derives network assignments for the Tracker service

Implements NET-01 through NET-03:

• NET-01: Metrics network if Prometheus enabled
• NET-02: Database network if MySQL enabled
• NET-03: Proxy network if Caddy enabled

impl PartialEq for TrackerConfig

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PortDerivation for TrackerConfig

fn derive_ports(&self) -> Vec<PortBinding>

Derives port bindings for the Tracker service

Implements PORT-01 through PORT-06:

• PORT-01: Tracker needs ports if UDP OR HTTP without TLS OR API without TLS
• PORT-02: UDP ports always exposed (UDP doesn’t use TLS)
• PORT-03: HTTP ports WITHOUT TLS exposed directly
• PORT-04: HTTP ports WITH TLS NOT exposed (Caddy handles)
• PORT-05: API port exposed only when no TLS
• PORT-06: API port NOT exposed when TLS

impl Serialize for TrackerConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for TrackerConfig

impl TryFrom<TrackerSection> for TrackerConfig

type Error = CreateConfigError

The type returned in the event of a conversion error.

fn try_from(section: TrackerSection) -> Result<Self, Self::Error>

Performs the conversion.