dinio_sdk/models/

health_check.rs

use std::collections::BTreeMap;

use serde::{Deserialize, Serialize};
use uuid::Uuid;

/// A health check on one record value (`record_id` is its key: one check per value).
/// Durations are seconds, as on the wire. It runs only while the value's
/// [`host_health`](crate::models::RecordValue::host_health) is
/// [`Auto`](crate::models::HostHealthMode::Auto); there is no separate on/off switch.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HealthCheck {
    /// The checked record value; also the check's id.
    pub record_id: Uuid,
    /// `http`, `tcp` or `ping`.
    #[serde(rename = "type")]
    pub check_type: String,
    /// Free-form label.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Type-specific settings; see [`HealthCheckConfig`] for the known shapes.
    pub config: serde_json::Value,
    /// Time between checks, seconds.
    pub interval: u32,
    /// Time one attempt may take, seconds.
    pub timeout: u32,
    /// Extra attempts before the value counts as unhealthy.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub retries: Option<u32>,
    /// Time between retries, seconds; Core waits 5 s when it is `None`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub retry_interval: Option<u32>,
    /// Live status: `UNKNOWN`, `HEALTHY` or `UNHEALTHY`. `UNKNOWN` while the value is not
    /// on `Auto` and before the first run after any mode change.
    pub last_status: String,
    /// Unix seconds; absent while the status is `UNKNOWN`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_checked_at: Option<i64>,
    /// Why the last attempt failed.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_error: Option<String>,
    /// Unix seconds.
    pub created_at: i64,
    /// Unix seconds.
    pub updated_at: i64,
}

impl HealthCheck {
    /// The config in its typed form, if the type and shape are known.
    pub fn typed_config(&self) -> Option<HealthCheckConfig> {
        serde_json::from_value(serde_json::json!({
            "type": self.check_type,
            "config": self.config,
        }))
        .ok()
    }
}

/// What to check. Serialized as `"type"` + `"config"` (`../core/src/api/health_checks.ts`).
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", content = "config", rename_all = "lowercase")]
pub enum HealthCheckConfig {
    /// An HTTP(S) request must return an accepted status.
    Http(HttpCheck),
    /// A TCP connection must open.
    Tcp(TcpCheck),
    /// An ICMP echo must be answered.
    Ping(PingCheck),
}

/// Settings of an `http` check.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct HttpCheck {
    /// http(s) URL.
    pub url: String,
    /// `GET` (default on Core's side), `POST` or `HEAD`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub method: Option<String>,
    /// Accepted status codes; Core's default when absent.
    #[serde(
        rename = "expectedStatus",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub expected_status: Option<Vec<u16>>,
    /// Extra request headers.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub headers: Option<BTreeMap<String, String>>,
    /// Request body (for `POST`).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub body: Option<String>,
}

/// Settings of a `tcp` check.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TcpCheck {
    /// Host name or IP address.
    pub host: String,
    /// Port, 1–65535.
    pub port: u16,
}

/// Settings of a `ping` check.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PingCheck {
    /// Host name or IP address.
    pub address: String,
}

/// `POST /health-checks` body. Besides the ranges below, Core requires one run to end
/// before the next is due: `timeout × (retries + 1) + retry_interval × retries < interval`
/// (with `retry_interval` 5 when `None`), otherwise
/// [`ErrorCode::Validation`](crate::ErrorCode::Validation).
#[derive(Debug, Clone, Serialize)]
pub struct NewHealthCheck {
    /// The record value to check.
    pub record_id: Uuid,
    /// What to check.
    #[serde(flatten)]
    pub config: HealthCheckConfig,
    /// Free-form label, up to 255 characters.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Seconds, 60–86 400.
    pub interval: u32,
    /// Seconds, 1–30.
    pub timeout: u32,
    /// 0–5; Core counts `None` as 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub retries: Option<u32>,
    /// Seconds, 5–60; Core waits 5 s when `None`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub retry_interval: Option<u32>,
}

/// `PATCH /health-checks/:record_id` body; `None` fields stay unchanged. `config`, when
/// given, **replaces** the whole config and must match the existing type (the type cannot
/// change). Core checks the run-length rule of [`NewHealthCheck`] against the patch
/// combined with the stored values.
#[derive(Debug, Clone, Default, Serialize)]
pub struct HealthCheckPatch {
    /// New label.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// New config object, the `config` part of [`HealthCheckConfig`] only (without
    /// `type`).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub config: Option<serde_json::Value>,
    /// Seconds; same range as [`NewHealthCheck::interval`].
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interval: Option<u32>,
    /// Seconds; same range as [`NewHealthCheck::timeout`].
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timeout: Option<u32>,
    /// 0–5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub retries: Option<u32>,
    /// Seconds, 5–60.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub retry_interval: Option<u32>,
}

impl HealthCheckPatch {
    /// Whether the patch changes nothing.
    pub fn is_empty(&self) -> bool {
        self.name.is_none()
            && self.config.is_none()
            && self.interval.is_none()
            && self.timeout.is_none()
            && self.retries.is_none()
            && self.retry_interval.is_none()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn new_check_wire_shape() {
        let check = NewHealthCheck {
            record_id: Uuid::nil(),
            config: HealthCheckConfig::Tcp(TcpCheck {
                host: "192.0.2.1".into(),
                port: 443,
            }),
            name: None,
            interval: 60,
            timeout: 5,
            retries: None,
            retry_interval: None,
        };
        assert_eq!(
            serde_json::to_value(&check).unwrap(),
            serde_json::json!({
                "record_id": "00000000-0000-0000-0000-000000000000",
                "type": "tcp",
                "config": { "host": "192.0.2.1", "port": 443 },
                "interval": 60,
                "timeout": 5,
            })
        );
    }

    #[test]
    fn typed_config_from_response() {
        let check: HealthCheck = serde_json::from_value(serde_json::json!({
            "record_id": "00000000-0000-0000-0000-000000000000",
            "type": "http",
            "config": { "url": "https://example.com/health", "expectedStatus": [200, 204] },
            "interval": 60, "timeout": 5,
            "last_status": "UNKNOWN", "last_checked_at": null, "last_error": null,
            "created_at": 1, "updated_at": 1
        }))
        .unwrap();
        let Some(HealthCheckConfig::Http(http)) = check.typed_config() else {
            panic!("expected http config")
        };
        assert_eq!(http.expected_status, Some(vec![200, 204]));
    }
}