filip/Stalwart
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Add 58 new DNS provider integrations

Browse Source
This commit is contained in:
Maurus Decimus
2026-05-18 20:07:08 +02:00
parent d5a458992b
commit 2c4a504497
18 changed files with 10564 additions and 307 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
crates/common/Cargo.toml
View File

@@ -20,7 +20,7 @@ mail-parser = { version = "0.11", features = ["full_encoding"] }
mail-builder = { version = "0.4" }
mail-auth = { version = "0.9", features = ["generate"] }
smtp-proto = { version = "0.2", features = ["rkyv"] }
dns-update = { version = "0.3" }
dns-update = { version = "0.4.0" }
calcard = { version = "0.3", features = ["rkyv"] }
ahash = { version = "0.8.2", features = ["serde"] }
parking_lot = "0.12.1"

888
crates/common/src/network/dns/update.rs
View File

@@ -75,23 +75,19 @@ impl DnsUpdater {
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Sig0(_) => {
Err("RFC 2136 with SIG(0) authentication is no longer supported".into())
}
DnsServer::Cloudflare(server) => {
let updater = {
#[cfg(feature = "test_mode")]
match server.email.as_deref() {
Some("test@pebble.org") => dns_update::DnsUpdater::new_pebble(
match server.secret.secret().await.unwrap().as_ref() {
"test@pebble.org" => dns_update::DnsUpdater::new_pebble(
"http://localhost:8055",
server.timeout.into_inner().into(),
),
Some("test@memory.org") => {
"test@memory.org" => {
dns_update::DnsUpdater::new_in_memory(DNS_RECORDS.clone())
}
_ => dns_update::DnsUpdater::new_cloudflare(
server.secret.secret().await?,
server.email,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
@@ -100,7 +96,6 @@ impl DnsUpdater {
#[cfg(not(feature = "test_mode"))]
dns_update::DnsUpdater::new_cloudflare(
server.secret.secret().await?,
server.email,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?
@@ -181,7 +176,7 @@ impl DnsUpdater {
core,
updater: dns_update::DnsUpdater::new_porkbun(
server.api_key.as_str(),
server.secret.secret().await?,
server.secret_api_key.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
@@ -193,7 +188,7 @@ impl DnsUpdater {
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_dnsimple(
server.secret.secret().await?,
server.auth_token.secret().await?,
server.account_identifier.as_str(),
server.timeout.into_inner().into(),
)
@@ -253,6 +248,869 @@ impl DnsUpdater {
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
})
}
DnsServer::Alidns(server) => {
let secret_key = server.secret_key.secret().await?.into_owned();
let security_token = server
.security_token
.secret()
.await?
.map(|c| c.into_owned());
Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_alidns(
server.access_key.as_str(),
secret_key.as_str(),
server.region.as_deref(),
security_token.as_deref(),
server.line.as_deref(),
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
})
}
DnsServer::ArvanCloud(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_arvancloud(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Autodns(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_autodns(
server.username.as_str(),
server.password.secret().await?,
server.context.map(|v| v as u32),
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::AzureDns(server) => {
let client_secret = server.client_secret.secret().await?.into_owned();
let config = dns_update::providers::azuredns::AzureDnsConfig {
tenant_id: server.tenant_id,
client_id: server.client_id,
client_secret,
subscription_id: server.subscription_id,
resource_group: server.resource_group,
environment: match server.environment {
enums::AzureEnvironment::Public => {
dns_update::providers::azuredns::AzureEnvironment::Public
}
enums::AzureEnvironment::China => {
dns_update::providers::azuredns::AzureEnvironment::China
}
enums::AzureEnvironment::UsGovernment => {
dns_update::providers::azuredns::AzureEnvironment::UsGovernment
}
},
request_timeout: Some(server.timeout.into_inner()),
};
Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_azuredns(config)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
})
}
DnsServer::BaiduCloud(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_baiducloud(
server.access_key.as_str(),
server.secret_key.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::BluecatV2(server) => {
let password = server.password.secret().await?.into_owned();
let config = dns_update::providers::bluecatv2::BluecatV2Config {
server_url: server.base_url,
username: server.username,
password,
config_name: server.config_name,
view_name: server.view_name,
skip_deploy: server.skip_deploy,
request_timeout: Some(server.timeout.into_inner()),
};
Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_bluecatv2(config)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
})
}
DnsServer::ClouDns(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_cloudns(
server.auth_id.as_deref(),
server.sub_auth_id.as_deref(),
server.password.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Constellix(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_constellix(
server.api_key.as_str(),
server.secret_key.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Cpanel(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_cpanel(
server.base_url.as_str(),
server.username.as_str(),
server.token.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Ddnss(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_ddnss(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::DnsMadeEasy(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_dnsmadeeasy(
server.api_key.as_str(),
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Domeneshop(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_domeneshop(
server.auth_token.as_str(),
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Dreamhost(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_dreamhost(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::DuckDns(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_duckdns(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Dynu(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_dynu(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::EasyDns(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_easydns(
server.token.as_str(),
server.key.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::EdgeDns(server) => {
let client_secret = server.client_secret.secret().await?.into_owned();
let access_token = server.access_token.secret().await?.into_owned();
let config = dns_update::providers::edgedns::EdgeDnsConfig {
host: server.host,
client_token: server.client_token,
client_secret,
access_token,
account_switch_key: server.account_switch_key,
request_timeout: Some(server.timeout.into_inner()),
};
Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_edgedns(config)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
})
}
DnsServer::Exoscale(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_exoscale(
server.api_key.as_str(),
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::FreeMyIp(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_freemyip(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::GandiV5(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_gandiv5(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Gcore(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_gcore(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Glesys(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_glesys(
server.api_user.as_str(),
server.api_key.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Godaddy(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_godaddy(
server.api_key.as_str(),
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Hetzner(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_hetzner(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::HostingDe(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_hostingde(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Hostinger(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_hostinger(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::HuaweiCloud(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_huaweicloud(
server.access_key.as_str(),
server.secret_key.secret().await?,
server.region.as_str(),
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Hurricane(server) => {
let mut credentials = std::collections::HashMap::new();
for cred in server.credentials.0.into_values() {
let secret = cred.secret.secret().await?.into_owned();
credentials.insert(cred.zone, secret);
}
Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_hurricane(
credentials,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
})
}
DnsServer::IbmCloud(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_ibmcloud(
server.username.as_str(),
server.api_key.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Infoblox(server) => {
let password = server.password.secret().await?.into_owned();
let config = dns_update::providers::infoblox::InfobloxConfig {
host: server.host,
port: server.port,
username: server.username,
password,
wapi_version: server.wapi_version,
dns_view: server.dns_view,
request_timeout: Some(server.timeout.into_inner()),
};
Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_infoblox(config)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
})
}
DnsServer::Infomaniak(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_infomaniak(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Inwx(server) => {
let password = server.password.secret().await?.into_owned();
let shared_secret = server.shared_secret.secret().await?.map(|c| c.into_owned());
Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_inwx(
server.username,
password,
shared_secret,
server.sandbox,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
})
}
DnsServer::Ionos(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_ionos(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Ipv64(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_ipv64(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Joker(server) => {
let auth = match server.auth {
registry::schema::structs::JokerAuth::ApiKey(api) => {
let key = api.api_key.secret().await?.into_owned();
dns_update::providers::joker::JokerAuth::api_key(key)
}
registry::schema::structs::JokerAuth::UsernamePassword(creds) => {
let password = creds.password.secret().await?.into_owned();
dns_update::providers::joker::JokerAuth::username_password(
creds.username,
password,
)
}
};
Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_joker(
auth,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
})
}
DnsServer::Lightsail(server) => {
let secret_access_key = server.secret_access_key.secret().await?.into_owned();
let session_token = server.session_token.secret().await?.map(|c| c.into_owned());
let config = dns_update::providers::lightsail::LightsailConfig {
access_key_id: server.access_key_id,
secret_access_key,
session_token,
region: server.region,
domain: server.domain,
request_timeout: Some(server.timeout.into_inner()),
};
Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_lightsail(config)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
})
}
DnsServer::Linode(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_linode(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::LuaDns(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_luadns(
server.username.as_str(),
server.auth_token.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::MythicBeasts(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_mythicbeasts(
server.username.as_str(),
server.password.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Namecheap(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_namecheap(
server.api_user.as_str(),
server.api_key.secret().await?,
server.client_ip.as_str(),
server.username.as_deref(),
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::NameDotCom(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_namedotcom(
server.username.as_str(),
server.auth_token.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::NameSilo(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_namesilo(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Netcup(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_netcup(
server.customer_number.as_str(),
server.api_key.as_str(),
server.password.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Netlify(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_netlify(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Nifcloud(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_nifcloud(
server.access_key.as_str(),
server.secret_key.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Ns1(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_ns1(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::OracleCloud(server) => {
let private_key_pem = server.private_key_pem.secret().await?.into_owned();
let private_key_password = server
.private_key_password
.secret()
.await?
.map(|c| c.into_owned());
let config = dns_update::providers::oraclecloud::OracleCloudConfig {
tenancy_ocid: server.tenancy_ocid,
user_ocid: server.user_ocid,
fingerprint: server.fingerprint,
private_key_pem,
private_key_password,
region: server.region,
compartment_ocid: server.compartment_ocid,
request_timeout: Some(server.timeout.into_inner()),
};
Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_oraclecloud(config)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
})
}
DnsServer::Plesk(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_plesk(
server.base_url.as_str(),
server.api_key.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Safedns(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_safedns(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Scaleway(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_scaleway(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::TencentCloud(server) => {
let secret_key = server.secret_key.secret().await?.into_owned();
let session_token = server.session_token.secret().await?.map(|c| c.into_owned());
Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_tencentcloud(
server.secret_id.as_str(),
secret_key.as_str(),
server.region.as_deref(),
session_token.as_deref(),
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
})
}
DnsServer::Transip(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_transip(
server.username.as_str(),
server.private_key_pem.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::UltraDns(server) => {
let password = server.password.secret().await?.into_owned();
Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_ultradns(
server.username,
password,
server.endpoint,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
})
}
DnsServer::Vercel(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_vercel(
server.auth_token.secret().await?,
server.team_id.as_deref(),
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::Volcengine(server) => {
let secret_key = server.secret_key.secret().await?.into_owned();
let config = dns_update::providers::volcengine::VolcengineConfig {
access_key: server.access_key,
secret_key,
region: server.region,
host: server.host,
scheme: server.scheme,
request_timeout: Some(server.timeout.into_inner()),
};
Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_volcengine(config)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
})
}
DnsServer::Vultr(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_vultr(
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::WebSupport(server) => Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_websupport(
server.api_key.as_str(),
server.secret.secret().await?,
server.timeout.into_inner().into(),
)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
}),
DnsServer::YandexCloud(server) => {
let iam_token_b64 = server.api_key.secret().await?.into_owned();
let config = dns_update::providers::yandexcloud::YandexCloudConfig {
iam_token_b64,
folder_id: server.folder_id,
request_timeout: Some(server.timeout.into_inner()),
};
Ok(DnsUpdater {
polling_interval: server.polling_interval.into_inner(),
propagation_timeout: server.propagation_timeout.into_inner(),
propagation_delay: server.propagation_delay.map(|d| d.into_inner()),
ttl: server.ttl.into_inner(),
core,
updater: dns_update::DnsUpdater::new_yandexcloud(config)
.map_err(|err| format!("Failed to build DNS updater: {}", err))?,
})
}
DnsServer::Deprecated1 => Err("DNS server type no longer supported".to_string()),
}
}
@@ -292,7 +1150,7 @@ impl DnsUpdater {
Hostname = name.to_string(),
Details = origin.to_string(),
Type = record.as_type().as_str(),
Value = format!("{:?}", record),
Value = record.to_string(),
);
if verify && let DnsRecord::TXT(txt_record) = &record {
@@ -324,7 +1182,7 @@ impl DnsUpdater {
Details = origin.to_string(),
Result = result.to_string(),
Type = record.as_type().as_str(),
Value = format!("{:?}", record),
Value = record.to_string(),
);
}
}
@@ -335,7 +1193,7 @@ impl DnsUpdater {
Details = origin.to_string(),
Reason = err.to_string(),
Type = record.as_type().as_str(),
Value = format!("{:?}", record),
Value = record.to_string(),
);
}
}
@@ -349,7 +1207,7 @@ impl DnsUpdater {
Hostname = name.to_string(),
Details = origin.to_string(),
Type = record.as_type().as_str(),
Value = format!("{:?}", record),
Value = record.to_string(),
);
} else {
trc::event!(
@@ -357,7 +1215,7 @@ impl DnsUpdater {
Hostname = name.to_string(),
Details = origin.to_string(),
Type = record.as_type().as_str(),
Value = format!("{:?}", record),
Value = record.to_string(),
);
}