rrdnsd/providers/

dynu.rs

// rrdnsd - Dynu API client
// Copyright 2025 Federico Ceratto <federico@debian.org>
// Released under AGPLv3

/// Dynu API
/// See https://www.dynu.com/Support/API
//
use anyhow::{bail, Result};
use log::{debug, info};
use serde::{Deserialize, Serialize};
use std::net::IpAddr;

use super::{new_reqw, record_type, SetProvider};

const API_BASEURL: &str = "https://api.dynu.com";

#[derive(Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct DynuRecord {
    id: u32,
    domain_id: u32,
    ipv4_address: IpAddr,
}

#[derive(Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
struct DynuRecordsResp {
    dns_records: Vec<DynuRecord>,
}

#[derive(Deserialize, Debug)]
struct DynuGetRoot {
    id: u32,
}

#[derive(Serialize, Debug)]
struct DynuAddPayload {
    group: String,
    #[serde(rename = "ipv4Address")]
    ipv4_address: String,
    #[serde(rename = "nodeName")]
    node_name: String,
    #[serde(rename = "recordType")]
    record_type: String,
    state: bool,
    ttl: u32,
}

fn extract_record_name(fqdn: &str, zone: &str) -> String {
    fqdn[..(fqdn.len() - zone.len() - 1)].to_owned()
}

async fn dynu_request(req: reqwest::RequestBuilder, token: &str) -> Result<reqwest::Response> {
    let res = req
        .header("accept", "application/json")
        .header("API-Key", token)
        .send()
        .await?;
    let status = res.status();
    if !status.is_success() {
        let error_body = res.text().await?;
        bail!("[dynu] API error {}: {}", status, error_body);
    }
    Ok(res)
}
pub struct Dynu;

impl SetProvider for Dynu {
    async fn add_record(token: &str, fqdn: &str, zone: &str, ipaddr: IpAddr) -> Result<()> {
        let reqw = new_reqw()?;

        debug!("[dynu] Fetching domain ID for {fqdn}");
        let domain_id = {
            let url = format!("{API_BASEURL}/v2/dns/getroot/{fqdn}");
            info!("Fetching {}", url);
            let res = dynu_request(reqw.get(url), token).await?;
            let r = res.json::<DynuGetRoot>().await?;
            r.id
        };
        debug!("[dynu] Received domain ID {domain_id}");

        let url = format!("{API_BASEURL}/v2/dns/{domain_id}/record");
        let payload = DynuAddPayload {
            group: String::new(),
            ipv4_address: ipaddr.to_string(),
            node_name: extract_record_name(fqdn, zone),
            record_type: record_type(ipaddr).to_string(),
            state: true,
            ttl: 30,
        };
        debug!("[dynu] Adding record {fqdn} to domain ID {domain_id}");
        dynu_request(reqw.post(url).json(&payload), token).await?;
        info!("[dynu] Adding record completed");
        Ok(())
    }

    async fn delete_record(token: &str, fqdn: &str, _zone: &str, ipaddr: IpAddr) -> Result<()> {
        let reqw = new_reqw()?;
        let existing_record: DynuRecord = 'found: {
            let rtype = record_type(ipaddr);
            let url = format!("{API_BASEURL}/v2/dns/record/{fqdn}?recordType={rtype}");
            let res = dynu_request(reqw.get(url), token).await?;
            let r = res.json::<DynuRecordsResp>().await?;
            for rdata in r.dns_records {
                if rdata.ipv4_address == ipaddr {
                    break 'found rdata;
                }
            }
            bail!("not found");
        };
        debug!("Found record {existing_record:?}");
        let url = format!(
            "{API_BASEURL}/v2/dns/{}/record/{}",
            existing_record.domain_id, existing_record.id
        );
        dynu_request(reqw.delete(url), token).await?;
        info!("[dynu] Deleting record {fqdn} completed");
        Ok(())
    }
}

/// cargo nextest run test_integ_dynu_add_delete  --run-ignored only
#[cfg(test)]
mod tests {
    use super::*;
    use crate::providers::{Dynu, SetProvider};
    use anyhow::bail;
    use log::info;
    use std::net::IpAddr;
    use tokio::process::Command;

    async fn lookup(fqdn: &str, resolver: &str) -> Result<Vec<IpAddr>> {
        let ns = format!("@{resolver}");
        let p = Command::new("dig")
            .args(["+short", fqdn, &ns])
            .output()
            .await?;
        if !p.status.success() {
            bail!("Unable to run dig");
        }
        let stdout = String::from_utf8_lossy(&p.stdout);
        let addrs: Vec<IpAddr> = stdout
            .lines()
            .filter_map(|line| line.trim().parse().ok())
            .collect();

        info!("dig {fqdn} -> {addrs:?}");
        Ok(addrs)
    }
    #[derive(serde::Deserialize)]
    struct Conf {
        token: String,
        zone: String,
        fqdn: String,
        ns: String, // nameserver
    }

    #[test]
    fn test_extract_record_name() {
        assert_eq!(extract_record_name("a.b.c.d", "b.c.d"), "a");
        assert_eq!(extract_record_name("aaa.b.c.d", "b.c.d"), "aaa");
    }

    #[test_log::test(tokio::test)]
    #[ignore]
    async fn test_integ_dynu_add_delete() -> Result<()> {
        let c: Conf = serde_json::from_str(include_str!("testdata/dynu.json"))?;
        let ipa = "1.2.3.4".parse()?;
        let orig_ipa = "1.1.1.1".parse()?;
        let addrs = lookup(&c.fqdn, &c.ns).await?;
        assert!(!addrs.contains(&ipa), "ipaddr not deleted {:?}", addrs);
        assert!(addrs.contains(&orig_ipa), "old ipaddr missing {:?}", addrs);

        info!("adding {ipa}");
        Dynu::add_record(&c.token, &c.fqdn, &c.zone, ipa).await?;

        tokio::time::sleep(tokio::time::Duration::from_secs(32)).await;
        let addrs = lookup(&c.fqdn, &c.ns).await?;
        assert!(addrs.contains(&ipa), "ipaddr not found {:?}", addrs);
        assert!(addrs.contains(&orig_ipa), "old ipaddr missing {:?}", addrs);

        info!("deleting {ipa}");
        Dynu::delete_record(&c.token, &c.fqdn, &c.zone, ipa).await?;

        tokio::time::sleep(tokio::time::Duration::from_secs(32)).await;
        let addrs = lookup(&c.fqdn, &c.ns).await?;
        assert!(!addrs.contains(&ipa), "ipaddr not deleted {:?}", addrs);
        assert!(addrs.contains(&orig_ipa), "old ipaddr missing {:?}", addrs);

        Ok(())
    }
}