Method check_dns

certbot/src/acme_client.rs:362–426

Self check the TXT records for the given challenges.

(&self, challenges: &[Challenge])

    /// Self check the TXT records for the given challenges.
    async fn check_dns(&self, challenges: &[Challenge]) -> Result<()> {
        use tracing::warn;

        let mut delay = Duration::from_millis(250);
        let mut tries = 1u8;

        let mut unsettled_challenges = challenges.to_vec();

        debug!("Unsettled challenges: {unsettled_challenges:#?}");

        let start_time = std::time::Instant::now();

        'outer: loop {
            use hickory_resolver::AsyncResolver;

            sleep(delay).await;

            let elapsed = start_time.elapsed();
            if elapsed >= self.max_dns_wait {
                warn!(
                    "DNS propagation timeout after {elapsed:?}, max wait time is {max:?}. proceeding anyway as ACME server may have different DNS view",
                    max = self.max_dns_wait
                );
                break;
            }

            let dns_resolver =
                AsyncResolver::tokio_from_system_conf().context("failed to create dns resolver")?;

            while let Some(challenge) = unsettled_challenges.pop() {
                let expected_txt = &challenge.dns_value;
                let settled = match dns_resolver.txt_lookup(&challenge.acme_domain).await {
                    Ok(record) => record.iter().any(|txt| {
                        let actual_txt = txt.to_string();
                        debug!("Expected challenge: {expected_txt}, actual: {actual_txt}");
                        actual_txt == *expected_txt
                    }),
                    Err(err) => {
                        let ResolveErrorKind::NoRecordsFound { .. } = err.kind() else {
                            bail!(
                                "failed to lookup dns record {}: {err}",
                                challenge.acme_domain
                            );
                        };
                        false
                    }
                };
                if !settled {
                    delay = Duration::from_secs(32).min(delay * 2);
                    tries += 1;
                    debug!(
                        tries,
                        domain = &challenge.acme_domain,
                        elapsed = ?elapsed,
                        max_wait = ?self.max_dns_wait,
                        "challenge not found, waiting for {delay:?}"
                    );
                    unsettled_challenges.push(challenge);