Struct HttpApiConfig 

pub struct HttpApiConfig { /* private fields */ }

HTTP API configuration with domain invariants enforced at construction

This type guarantees that any instance is valid according to domain rules:

• Bind address has a non-zero port
• If TLS proxy is enabled, a domain is configured
• If TLS proxy is enabled, bind address is not localhost

Construction

Use HttpApiConfig::new() to create instances with validation:

use torrust_tracker_deployer_lib::domain::tracker::HttpApiConfig;
use torrust_tracker_deployer_lib::shared::ApiToken;

let config = HttpApiConfig::new(
    "0.0.0.0:1212".parse().unwrap(),
    ApiToken::from("MyToken".to_string()),
    None,
    false,
)?;

Invariants

The following invariants are enforced at construction time:

1. No dynamic ports: bind_address.port() != 0
2. TLS requires domain: use_tls_proxy == true implies domain.is_some()
3. No localhost with TLS: use_tls_proxy == true implies !is_localhost(bind_address)

Implementations

impl HttpApiConfig

pub fn new( bind_address: SocketAddr, admin_token: ApiToken, domain: Option<DomainName>, use_tls_proxy: bool, ) -> Result<Self, HttpApiConfigError>

Creates a new HTTP API configuration with validation

This is the primary way to construct an HttpApiConfig. All domain invariants are validated before the instance is created.

Arguments

• bind_address - Socket address to bind to (e.g., “0.0.0.0:1212”)
• admin_token - API token for authentication
• domain - Optional domain for TLS certificate (required if use_tls_proxy is true)
• use_tls_proxy - Whether to enable TLS via Caddy reverse proxy

Errors

Returns HttpApiConfigError if any invariant is violated:

• DynamicPortNotSupported - if port is 0
• TlsProxyRequiresDomain - if use_tls_proxy is true but domain is None
• LocalhostWithTls - if use_tls_proxy is true and bind_address is localhost

Examples

use torrust_tracker_deployer_lib::domain::tracker::HttpApiConfig;
use torrust_tracker_deployer_lib::shared::{ApiToken, DomainName};

// Basic configuration without TLS
let config = HttpApiConfig::new(
    "0.0.0.0:1212".parse().unwrap(),
    ApiToken::from("MyToken".to_string()),
    None,
    false,
)?;

// Configuration with TLS (requires domain)
let tls_config = HttpApiConfig::new(
    "0.0.0.0:1212".parse().unwrap(),
    ApiToken::from("MyToken".to_string()),
    Some(DomainName::new("api.example.com")?),
    true,
)?;

pub fn bind_address(&self) -> SocketAddr

Returns the bind address

pub fn admin_token(&self) -> &ApiToken

Returns a reference to the admin token

pub fn domain(&self) -> Option<&DomainName>

Returns a reference to the domain, if configured

pub fn use_tls_proxy(&self) -> bool

Returns whether TLS proxy is enabled

pub fn uses_tls_proxy(&self) -> bool

Returns true if this API uses the TLS proxy

Alias for use_tls_proxy() for semantic clarity.

pub fn tls_domain(&self) -> Option<&DomainName>

Returns the domain name if TLS proxy is enabled

Returns None if TLS is disabled, even if a domain is configured. This is useful for determining the effective TLS domain.

Trait Implementations

impl Clone for HttpApiConfig

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 HttpApiConfig

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for HttpApiConfig

Enables deserialization with validation through TryFrom

This ensures that JSON deserialization also validates the config, maintaining the “always valid” invariant even for loaded data.

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for HttpApiConfig

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

Formats the value using the given formatter.

impl PartialEq for HttpApiConfig

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for HttpApiConfig

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 HttpApiConfig

impl TryFrom<HttpApiSection> for HttpApiConfig

Converts HttpApiSection (DTO) to HttpApiConfig (Domain)

This implementation:

1. Parses the bind address string to SocketAddr
2. Parses the domain string to DomainName (if present)
3. Delegates business validation to HttpApiConfig::new()

Errors

Returns CreateConfigError:

• InvalidBindAddress - if bind address cannot be parsed as IP:PORT
• InvalidDomain - if domain string is not a valid domain name
• HttpApiConfigInvalid - if domain invariants are violated (port 0, TLS without domain, etc.)

Example

use torrust_tracker_deployer_lib::application::command_handlers::create::config::tracker::HttpApiSection;
use torrust_tracker_deployer_lib::domain::tracker::HttpApiConfig;

let section = HttpApiSection {
    bind_address: "0.0.0.0:1212".to_string(),
    admin_token: "MyToken".to_string(),
    domain: None,
    use_tls_proxy: None,
};

let config: HttpApiConfig = section.try_into()?;
assert_eq!(config.bind_address().port(), 1212);

type Error = CreateConfigError

The type returned in the event of a conversion error.

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

Performs the conversion.