use anyhow::{anyhow, bail, Context, Result}; use crimp::Request; use std::env; use std::net::Ipv4Addr; use tokio::runtime; use yandex_cloud::tonic_exports::{Channel, Endpoint, InterceptedService}; use yandex_cloud::yandex::cloud::dns::v1 as dns; use yandex_cloud::yandex::cloud::dns::v1::dns_zone_service_client::DnsZoneServiceClient; use yandex_cloud::{AuthInterceptor, TokenProvider}; type DnsClient = DnsZoneServiceClient>>; /// Fetch the current IP from the given URL. It should be the URL of a /// site that responds only with the IP in plain text, and nothing else. fn get_current_ip(source: &str) -> Result { let response = Request::get(source) .send() .context("failed to fetch current IP")? .error_for_status(|resp| anyhow!("error response ({})", resp.status)) .context("received error response for IP")? .as_string()? .body; Ok(response.trim().parse().with_context(|| { format!( "failed to parse IP address from response body: {}", response ) })?) } /// Fetch the current address of the target record. async fn fetch_current_record_addr( client: &mut DnsClient, zone_id: &str, record_name: &str, ) -> Result { let req = dns::GetDnsZoneRecordSetRequest { dns_zone_id: zone_id.into(), name: record_name.into(), r#type: "A".into(), }; let response = client .get_record_set(req) .await .context("failed to fetch current record set")? .into_inner(); if response.data.len() != 1 { bail!( "expected exactly one record for 'A {}', but found {}", record_name, response.data.len() ); } Ok(response.data[0] .parse() .context("failed to parse returned record")?) } /// Update the record with the new address, if required. async fn update_record( client: &mut DnsClient, zone_id: &str, record_name: &str, new_address: Ipv4Addr, ) -> Result<()> { let request = dns::UpsertRecordSetsRequest { dns_zone_id: zone_id.into(), replacements: vec![dns::RecordSet { name: record_name.into(), r#type: "A".into(), ttl: 3600, // 1 hour data: vec![new_address.to_string()], }], ..Default::default() }; client .upsert_record_sets(request) .await .context("failed to update record")?; Ok(()) } /// Compare the record with the expected value, and issue an update if /// necessary. async fn compare_update_record( client: &mut DnsClient, zone_id: &str, record_name: &str, new_ip: Ipv4Addr, ) -> Result<()> { let old_ip = fetch_current_record_addr(client, zone_id, record_name).await?; if old_ip == new_ip { println!("IP address unchanged ({})", old_ip); return Ok(()); } println!( "IP address changed: current record points to {}, but address is {}", old_ip, new_ip ); update_record(client, zone_id, record_name, new_ip).await?; println!("successfully updated '{}' to 'A {}'", record_name, new_ip); Ok(()) } fn main() -> Result<()> { let token = env::var("YANDEX_CLOUD_TOKEN").context("Yandex Cloud authentication token unset")?; let target_zone_id = env::var("TARGET_ZONE").unwrap_or_else(|_| "dnsd0tif5mokfu0mg8i5".to_string()); let target_record = env::var("TARGET_RECORD").unwrap_or_else(|_| "khtrsk".to_string()); let current_ip = get_current_ip("http://ifconfig.me")?; println!("current IP address is '{}'", current_ip); let rt = runtime::Builder::new_current_thread() .enable_time() .enable_io() .build()?; rt.block_on(async move { let channel = Endpoint::from_static("https://dns.api.cloud.yandex.net") .connect() .await?; let mut client = DnsZoneServiceClient::with_interceptor(channel, AuthInterceptor::new(token)); compare_update_record(&mut client, &target_zone_id, &target_record, current_ip).await })?; Ok(()) }