1#[cfg(feature = "resolvers")]
2use std::{
3 error::Error,
4 fmt::{self, Display},
5 sync::Arc,
6};
7
8#[cfg(feature = "resolvers")]
9use dquic::{
10 qbase::net::addr::EndpointAddr,
11 qresolve::{Resolve, ResolveFuture, Source},
12};
13#[cfg(feature = "resolvers")]
14use futures::{FutureExt, Stream, StreamExt, TryFutureExt, stream};
15#[cfg(feature = "resolvers")]
16use tokio::io;
17
18#[cfg(feature = "h3")]
19pub use crate::h3::H3Resolver;
20#[cfg(feature = "http")]
21pub use crate::http::HttpResolver;
22#[cfg(feature = "mdns")]
23pub use crate::mdns::MdnsResolver;
24#[cfg(all(feature = "mdns", feature = "dquic-network", feature = "resolvers"))]
25use crate::mdns::MdnsResolvers;
26
27pub(crate) fn resolvable_name(name: &str) -> Option<&str> {
31 let host = match name.rsplit_once(':') {
32 Some((h, port)) if !port.is_empty() && port.chars().all(|c| c.is_ascii_digit()) => h,
33 _ => name,
34 };
35 rustls::pki_types::DnsName::try_from(host).ok()?;
36 Some(host)
37}
38
39#[cfg_attr(
40 not(any(feature = "h3", feature = "http", feature = "mdns")),
41 allow(dead_code)
42)]
43pub(crate) fn endpoint_lookup_name_and_sequence(
44 name: &str,
45) -> Option<(
46 &str,
47 Option<dhttp_identity::certificate::CertificateSequence>,
48)> {
49 use dhttp_identity::certificate::CertificateSequence;
50
51 let (host, sequence) = match name.rsplit_once(':') {
52 Some((host, digits))
53 if !digits.is_empty() && digits.chars().all(|c| c.is_ascii_digit()) =>
54 {
55 let sequence = digits.parse::<u64>().ok()?;
56 let sequence = CertificateSequence::try_from(sequence).ok()?;
57 (host, Some(sequence))
58 }
59 _ => (name, None),
60 };
61
62 Some((resolvable_name(host)?, sequence))
63}
64
65pub const DHTTP_H3_DNS_SERVER: &str = crate::bootstrap::DHTTP_H3_DNS_SERVER;
67
68pub const DHTTP_BOOTSTRAP_URL: &str = crate::bootstrap::DHTTP_BOOTSTRAP_URL;
70
71pub const DHTTP_MDNS_SERVICE: &str = crate::bootstrap::DHTTP_MDNS_SERVICE;
73
74#[cfg(feature = "resolvers")]
75#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
76pub enum DnsScheme {
77 Mdns,
78 Http,
79 H3,
80 System,
81}
82
83#[cfg(feature = "resolvers")]
84impl Display for DnsScheme {
85 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
86 f.write_str(match self {
87 Self::Mdns => "mdns",
88 Self::Http => "http",
89 Self::H3 => "h3",
90 Self::System => "system",
91 })
92 }
93}
94
95#[cfg(feature = "resolvers")]
96#[derive(Debug, snafu::Snafu)]
97#[snafu(display("unsupported dns scheme {scheme}"))]
98pub struct ParseDnsSchemeError {
99 scheme: String,
100}
101
102#[cfg(feature = "resolvers")]
103impl std::str::FromStr for DnsScheme {
104 type Err = ParseDnsSchemeError;
105
106 fn from_str(s: &str) -> Result<Self, Self::Err> {
107 match s {
108 "mdns" => Ok(Self::Mdns),
109 "http" => Ok(Self::Http),
110 "h3" => Ok(Self::H3),
111 "system" => Ok(Self::System),
112 scheme => Err(ParseDnsSchemeError {
113 scheme: scheme.to_owned(),
114 }),
115 }
116 }
117}
118
119pub mod deferred;
120pub mod endpoint_candidates;
121#[cfg(any(feature = "mdns", test))]
122pub(crate) mod endpoint_group;
123pub mod weak;
124
125#[cfg(feature = "resolvers")]
126type ArcResolver = Arc<dyn Resolve + Send + Sync + 'static>;
127
128#[cfg(feature = "resolvers")]
129#[derive(Clone)]
130struct ResolverEntry {
131 resolver: ArcResolver,
132 endpoint_candidates:
133 Option<crate::resolvers::endpoint_candidates::ArcEndpointCandidateResolver>,
134}
135
136#[cfg(feature = "resolvers")]
137impl fmt::Debug for ResolverEntry {
138 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
139 f.debug_struct("ResolverEntry")
140 .field("resolver", &self.resolver.to_string())
141 .field(
142 "supports_endpoint_candidates",
143 &self.endpoint_candidates.is_some(),
144 )
145 .finish()
146 }
147}
148
149#[cfg(feature = "resolvers")]
150#[derive(Default, Clone, Debug)]
151pub struct Resolvers {
152 resolvers: Vec<ResolverEntry>,
153}
154
155#[cfg(feature = "resolvers")]
156impl Display for Resolvers {
157 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
158 f.write_str("Resolvers(")?;
159 if self.resolvers.is_empty() {
160 f.write_str("empty")?;
161 } else {
162 for (i, entry) in self.resolvers.iter().enumerate() {
163 if i > 0 {
164 f.write_str(", ")?;
165 }
166 fmt::Display::fmt(entry.resolver.as_ref(), f)?;
167 }
168 }
169 f.write_str(")")
170 }
171}
172
173#[cfg(feature = "resolvers")]
174#[derive(Debug)]
175pub struct ResolversError {
176 errors: Vec<(String, io::Error)>,
177}
178
179#[cfg(feature = "resolvers")]
180fn format_dns_error_sources(
181 f: &mut fmt::Formatter<'_>,
182 error: &(dyn Error + 'static),
183) -> fmt::Result {
184 let mut index = 1;
185 let mut current = error.source();
186
187 while let Some(source) = current {
188 write!(f, "\n {index}. {source}")?;
189 index += 1;
190 current = source.source();
191 }
192
193 Ok(())
194}
195
196#[cfg(feature = "resolvers")]
197fn format_dns_error_entry(
198 f: &mut fmt::Formatter<'_>,
199 resolver: &str,
200 error: &io::Error,
201) -> fmt::Result {
202 write!(f, "\n - {resolver}: {error}")?;
203 format_dns_error_sources(f, error)
204}
205
206#[cfg(feature = "resolvers")]
207impl fmt::Display for ResolversError {
208 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
209 if self.errors.is_empty() {
210 return write!(f, "no DNS resolvers available");
211 }
212
213 write!(f, "all DNS resolvers failed")?;
214 for (resolver, error) in &self.errors {
215 format_dns_error_entry(f, resolver, error)?;
216 }
217 Ok(())
218 }
219}
220
221#[cfg(feature = "resolvers")]
222impl Error for ResolversError {}
223
224#[cfg(feature = "resolvers")]
225#[derive(Default)]
226pub struct ResolversBuilder {
227 resolvers: Resolvers,
228}
229
230#[cfg(feature = "resolvers")]
231impl ResolversBuilder {
232 pub fn resolver(mut self, resolver: ArcResolver) -> Self {
233 self.resolvers.push(resolver);
234 self
235 }
236
237 pub fn candidate_resolver<R>(mut self, resolver: Arc<R>) -> Self
238 where
239 R: crate::resolvers::endpoint_candidates::ResolveEndpointCandidates + Send + Sync + 'static,
240 {
241 self.resolvers.push_candidate_resolver(resolver);
242 self
243 }
244
245 #[cfg(all(feature = "mdns", feature = "dquic-network"))]
246 pub async fn mdns(
247 mut self,
248 network: Arc<h3x::dquic::Network>,
249 patterns: Arc<Vec<h3x::dquic::binds::BindPattern>>,
250 ) -> Self {
251 let mdns = Arc::new(MdnsResolvers::bind(network, patterns, DHTTP_MDNS_SERVICE).await);
252 self.resolvers.push_candidate_resolver(mdns);
253 self
254 }
255
256 #[cfg(feature = "h3")]
257 pub fn h3<C>(
258 self,
259 endpoint: Arc<h3x::endpoint::H3Endpoint<C, C::Connection>>,
260 ) -> io::Result<Self>
261 where
262 C: h3x::quic::Connect + h3x::quic::WithLocalAuthority + Send + Sync + 'static,
263 C::Error: Send + Sync + 'static,
264 C::Connection: Send + 'static,
265 {
266 self.h3_with_base_url(DHTTP_H3_DNS_SERVER, endpoint)
267 }
268
269 #[cfg(feature = "h3")]
270 pub fn h3_with_base_url<C>(
271 mut self,
272 base_url: impl AsRef<str>,
273 endpoint: Arc<h3x::endpoint::H3Endpoint<C, C::Connection>>,
274 ) -> io::Result<Self>
275 where
276 C: h3x::quic::Connect + h3x::quic::WithLocalAuthority + Send + Sync + 'static,
277 C::Error: Send + Sync + 'static,
278 C::Connection: Send + 'static,
279 {
280 let resolver = Arc::new(H3Resolver::from_endpoint(base_url, endpoint)?);
281 self.resolvers.push_candidate_resolver(resolver);
282 Ok(self)
283 }
284
285 #[cfg(feature = "http")]
286 pub fn http(self) -> io::Result<Self> {
287 self.http_with_base_url(DHTTP_BOOTSTRAP_URL)
288 }
289
290 #[cfg(feature = "http")]
291 pub fn http_with_base_url(mut self, base_url: impl AsRef<str>) -> io::Result<Self> {
292 let resolver = Arc::new(HttpResolver::new(base_url.as_ref())?);
293 self.resolvers.push_candidate_resolver(resolver);
294 Ok(self)
295 }
296
297 pub fn system(mut self) -> Self {
298 self.resolvers
299 .push(Arc::new(dquic::qresolve::SystemResolver));
300 self
301 }
302
303 pub fn build(self) -> Resolvers {
304 self.resolvers
305 }
306}
307
308#[cfg(feature = "resolvers")]
309impl Resolvers {
310 pub fn builder() -> ResolversBuilder {
311 ResolversBuilder::default()
312 }
313
314 pub fn new() -> Self {
315 Self::default()
316 }
317
318 pub fn with(mut self, resolver: ArcResolver) -> Self {
319 self.push(resolver);
320 self
321 }
322
323 pub fn with_candidate_resolver<R>(mut self, resolver: Arc<R>) -> Self
324 where
325 R: crate::resolvers::endpoint_candidates::ResolveEndpointCandidates + Send + Sync + 'static,
326 {
327 self.push_candidate_resolver(resolver);
328 self
329 }
330
331 pub fn push(&mut self, resolver: ArcResolver) {
332 self.resolvers.push(ResolverEntry {
333 resolver,
334 endpoint_candidates: None,
335 });
336 }
337
338 pub fn push_candidate_resolver<R>(&mut self, resolver: Arc<R>)
339 where
340 R: crate::resolvers::endpoint_candidates::ResolveEndpointCandidates + Send + Sync + 'static,
341 {
342 let endpoint_candidates =
343 Some(resolver.clone()
344 as crate::resolvers::endpoint_candidates::ArcEndpointCandidateResolver);
345 let resolver = resolver as ArcResolver;
346 self.resolvers.push(ResolverEntry {
347 resolver,
348 endpoint_candidates,
349 });
350 }
351
352 pub fn iter(&self) -> impl Iterator<Item = &ArcResolver> {
353 self.resolvers.iter().map(|entry| &entry.resolver)
354 }
355
356 pub async fn lookup_endpoint_candidates(
357 &self,
358 name: &str,
359 lookup: crate::resolvers::endpoint_candidates::EndpointLookup,
360 ) -> Result<crate::resolvers::endpoint_candidates::EndpointCandidates, ResolversError> {
361 let mut errors = vec![];
362 let mut groups =
363 Vec::<crate::resolvers::endpoint_candidates::EndpointCandidateGroup>::new();
364
365 for entry in self.resolvers.clone() {
366 let Some(candidate_resolver) = entry.endpoint_candidates else {
367 errors.push((
368 entry.resolver.to_string(),
369 io::Error::other("resolver does not support endpoint candidate lookup"),
370 ));
371 continue;
372 };
373
374 match candidate_resolver
375 .lookup_endpoint_candidates(name, lookup)
376 .await
377 {
378 Ok(candidates) => {
379 for mut group in candidates.groups {
380 if let Some(existing) = groups
381 .iter_mut()
382 .find(|existing| existing.chain == group.chain)
383 {
384 for endpoint in group.endpoints.drain(..) {
385 if !existing.endpoints.contains(&endpoint) {
386 existing.endpoints.push(endpoint);
387 }
388 }
389 for source in group.sources.drain(..) {
390 if !existing.sources.contains(&source) {
391 existing.sources.push(source);
392 }
393 }
394 } else {
395 groups.push(group);
396 }
397 }
398 }
399 Err(error) => errors.push((entry.resolver.to_string(), error)),
400 }
401 }
402
403 if groups.is_empty() && !errors.is_empty() {
404 return Err(ResolversError { errors });
405 }
406
407 Ok(crate::resolvers::endpoint_candidates::EndpointCandidates { groups })
408 }
409
410 pub async fn lookup(
411 &self,
412 name: &str,
413 ) -> Result<impl Stream<Item = (Source, EndpointAddr)> + use<>, ResolversError> {
414 let mut errors = vec![];
415
416 let mut lookups = stream::FuturesUnordered::from_iter(
417 (self.resolvers.clone().into_iter()).map(|entry| {
418 let resolver = entry.resolver.clone();
419 let name = name.to_string();
420 async move { (resolver.lookup(&name).await, resolver.clone()) }
421 }),
422 );
423
424 let endpoints = loop {
425 match lookups.next().await {
426 Some((Ok(endpoints), _)) => break endpoints,
427 Some((Err(error), resolver)) => errors.push((resolver.to_string(), error)),
428 None => return Err(ResolversError { errors }),
429 }
430 };
431
432 Ok(endpoints.chain(lookups.flat_map(|(endpoints, _)| stream::iter(endpoints).flatten())))
433 }
434}
435
436#[cfg(feature = "resolvers")]
437impl crate::resolvers::endpoint_candidates::ResolveEndpointCandidates for Resolvers {
438 fn lookup_endpoint_candidates<'a>(
439 &'a self,
440 name: &'a str,
441 lookup: crate::resolvers::endpoint_candidates::EndpointLookup,
442 ) -> crate::resolvers::endpoint_candidates::EndpointCandidateFuture<'a> {
443 async move {
444 Resolvers::lookup_endpoint_candidates(self, name, lookup)
445 .await
446 .map_err(io::Error::other)
447 }
448 .boxed()
449 }
450}
451
452#[cfg(feature = "resolvers")]
453impl Resolve for Resolvers {
454 fn lookup<'l>(&'l self, name: &'l str) -> ResolveFuture<'l> {
455 self.lookup(name)
456 .map_ok(StreamExt::boxed)
457 .map_err(io::Error::other)
458 .boxed()
459 }
460}
461
462#[cfg(test)]
463mod tests {
464 #[cfg(all(feature = "mdns", feature = "dquic-network", feature = "resolvers"))]
465 use std::str::FromStr;
466 #[cfg(feature = "resolvers")]
467 use std::{error::Error as StdError, fmt, io, sync::Arc};
468
469 #[cfg(all(feature = "mdns", feature = "dquic-network", feature = "resolvers"))]
470 use super::MdnsResolvers;
471 #[cfg(feature = "resolvers")]
472 use super::Resolvers;
473 use super::{DHTTP_BOOTSTRAP_URL, DHTTP_H3_DNS_SERVER, DHTTP_MDNS_SERVICE, resolvable_name};
474 #[cfg(feature = "resolvers")]
475 use super::{DnsScheme, ResolversError};
476
477 #[cfg(feature = "resolvers")]
478 #[derive(Debug)]
479 struct TestSourceError {
480 message: &'static str,
481 source: Option<Box<TestSourceError>>,
482 }
483
484 #[cfg(feature = "resolvers")]
485 impl TestSourceError {
486 fn leaf(message: &'static str) -> Self {
487 Self {
488 message,
489 source: None,
490 }
491 }
492
493 fn with_source(message: &'static str, source: TestSourceError) -> Self {
494 Self {
495 message,
496 source: Some(Box::new(source)),
497 }
498 }
499 }
500
501 #[cfg(feature = "resolvers")]
502 impl fmt::Display for TestSourceError {
503 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
504 f.write_str(self.message)
505 }
506 }
507
508 #[cfg(feature = "resolvers")]
509 impl StdError for TestSourceError {
510 fn source(&self) -> Option<&(dyn StdError + 'static)> {
511 self.source
512 .as_deref()
513 .map(|source| source as &(dyn StdError + 'static))
514 }
515 }
516
517 #[cfg(feature = "resolvers")]
518 fn other_error(message: &'static str) -> io::Error {
519 io::Error::other(message)
520 }
521
522 #[cfg(feature = "resolvers")]
523 fn chained_other_error(root: TestSourceError) -> io::Error {
524 io::Error::other(root)
525 }
526
527 #[test]
528 fn resolver_defaults_come_from_compile_time_environment() {
529 if let Some(expected) = option_env!("DHTTP_H3_DNS_SERVER") {
530 assert_eq!(DHTTP_H3_DNS_SERVER, expected);
531 }
532 if let Some(expected) = option_env!("DHTTP_BOOTSTRAP_URL") {
533 assert_eq!(DHTTP_BOOTSTRAP_URL, expected);
534 }
535 if let Some(expected) = option_env!("DHTTP_MDNS_SERVICE") {
536 assert_eq!(DHTTP_MDNS_SERVICE, expected);
537 }
538 }
539
540 #[test]
541 fn resolvable_name_accepts_dns_name_with_numeric_port() {
542 assert_eq!(
543 resolvable_name("example.dhttp.net:443"),
544 Some("example.dhttp.net")
545 );
546 }
547
548 #[test]
549 fn resolvable_name_accepts_stun_authority_with_numeric_port() {
550 assert_eq!(
551 resolvable_name("nat.genmeta.net:20004"),
552 Some("nat.genmeta.net")
553 );
554 }
555
556 #[test]
557 fn resolvable_name_rejects_ip_literals() {
558 assert_eq!(resolvable_name("127.0.0.1:443"), None);
559 assert_eq!(resolvable_name("[::1]:443"), None);
560 }
561
562 #[test]
563 fn endpoint_lookup_name_and_sequence_accepts_plain_name() {
564 let (name, sequence) =
565 super::endpoint_lookup_name_and_sequence("example.dhttp.net").expect("dns name");
566
567 assert_eq!(name, "example.dhttp.net");
568 assert_eq!(sequence, None);
569 }
570
571 #[test]
572 fn endpoint_lookup_name_and_sequence_parses_numeric_selector() {
573 let (name, sequence) =
574 super::endpoint_lookup_name_and_sequence("reimu.hakurei.dhttp.net:1")
575 .expect("dns name");
576
577 assert_eq!(name, "reimu.hakurei.dhttp.net");
578 assert_eq!(
579 sequence.map(dhttp_identity::certificate::CertificateSequence::get),
580 Some(1)
581 );
582 }
583
584 #[test]
585 fn endpoint_lookup_name_and_sequence_rejects_out_of_range_selector() {
586 let invalid = format!("example.dhttp.net:{}", (1u64 << 62) + 1);
587
588 assert_eq!(super::endpoint_lookup_name_and_sequence(&invalid), None);
589 }
590
591 #[cfg(feature = "resolvers")]
592 #[derive(Debug)]
593 struct CandidateResolver {
594 label: &'static str,
595 sequence: u8,
596 }
597
598 #[cfg(feature = "resolvers")]
599 impl fmt::Display for CandidateResolver {
600 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
601 f.write_str(self.label)
602 }
603 }
604
605 #[cfg(feature = "resolvers")]
606 impl dquic::qresolve::Resolve for CandidateResolver {
607 fn lookup<'l>(&'l self, _name: &'l str) -> dquic::qresolve::ResolveFuture<'l> {
608 use futures::{FutureExt, StreamExt, stream};
609 async { Ok(stream::empty().boxed()) }.boxed()
610 }
611 }
612
613 #[cfg(feature = "resolvers")]
614 impl crate::resolvers::endpoint_candidates::ResolveEndpointCandidates for CandidateResolver {
615 fn lookup_endpoint_candidates<'a>(
616 &'a self,
617 _name: &'a str,
618 _lookup: crate::resolvers::endpoint_candidates::EndpointLookup,
619 ) -> crate::resolvers::endpoint_candidates::EndpointCandidateFuture<'a> {
620 use dhttp_identity::certificate::CertificateSequence;
621 use dquic::qresolve::Source;
622 use futures::FutureExt;
623
624 let sequence = self.sequence;
625 async move {
626 Ok(crate::resolvers::endpoint_candidates::EndpointCandidates {
627 groups: vec![
628 crate::resolvers::endpoint_candidates::EndpointCandidateGroup {
629 chain: crate::core::certificate::primary_chain_key(
630 CertificateSequence::from(sequence),
631 ),
632 endpoints: Vec::new(),
633 sources: vec![Source::Dht],
634 },
635 ],
636 })
637 }
638 .boxed()
639 }
640 }
641
642 #[cfg(feature = "resolvers")]
643 #[tokio::test]
644 async fn aggregate_endpoint_candidates_preserve_resolver_order() {
645 let resolvers = Resolvers::new()
646 .with_candidate_resolver(Arc::new(CandidateResolver {
647 label: "a",
648 sequence: 1,
649 }))
650 .with_candidate_resolver(Arc::new(CandidateResolver {
651 label: "b",
652 sequence: 0,
653 }));
654
655 let candidates = resolvers
656 .lookup_endpoint_candidates(
657 "demo.dhttp.net",
658 crate::resolvers::endpoint_candidates::EndpointLookup::default(),
659 )
660 .await
661 .expect("candidate lookup succeeds");
662
663 assert_eq!(candidates.groups.len(), 2);
664 assert_eq!(candidates.groups[0].chain.usage().kind_flag(), "0");
665 assert_eq!(candidates.groups[0].chain.sequence().get(), 1);
666 assert_eq!(candidates.groups[1].chain.usage().kind_flag(), "0");
667 assert_eq!(candidates.groups[1].chain.sequence().get(), 0);
668 }
669
670 #[cfg(feature = "resolvers")]
671 #[derive(Debug)]
672 struct CandidateSetResolver {
673 label: &'static str,
674 groups: Vec<(u8, &'static str, dquic::qresolve::Source)>,
675 }
676
677 #[cfg(feature = "resolvers")]
678 impl fmt::Display for CandidateSetResolver {
679 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
680 f.write_str(self.label)
681 }
682 }
683
684 #[cfg(feature = "resolvers")]
685 impl dquic::qresolve::Resolve for CandidateSetResolver {
686 fn lookup<'l>(&'l self, _name: &'l str) -> dquic::qresolve::ResolveFuture<'l> {
687 use futures::{FutureExt, StreamExt, stream};
688 async { Ok(stream::empty().boxed()) }.boxed()
689 }
690 }
691
692 #[cfg(feature = "resolvers")]
693 impl crate::resolvers::endpoint_candidates::ResolveEndpointCandidates for CandidateSetResolver {
694 fn lookup_endpoint_candidates<'a>(
695 &'a self,
696 _name: &'a str,
697 _lookup: crate::resolvers::endpoint_candidates::EndpointLookup,
698 ) -> crate::resolvers::endpoint_candidates::EndpointCandidateFuture<'a> {
699 use dhttp_identity::certificate::CertificateSequence;
700 use futures::FutureExt;
701
702 let groups = self
703 .groups
704 .iter()
705 .map(|(sequence, endpoint, source)| {
706 crate::resolvers::endpoint_candidates::EndpointCandidateGroup {
707 chain: crate::core::certificate::primary_chain_key(
708 CertificateSequence::from(*sequence),
709 ),
710 endpoints: vec![dquic::qbase::net::addr::EndpointAddr::direct(
711 endpoint.parse().unwrap(),
712 )],
713 sources: vec![source.clone()],
714 }
715 })
716 .collect();
717 async move { Ok(crate::resolvers::endpoint_candidates::EndpointCandidates { groups }) }
718 .boxed()
719 }
720 }
721
722 #[cfg(feature = "resolvers")]
723 #[tokio::test]
724 async fn aggregate_endpoint_candidates_merge_duplicate_sequences_stably() {
725 use dquic::qresolve::Source;
726
727 let resolvers = Resolvers::new()
728 .with_candidate_resolver(Arc::new(CandidateSetResolver {
729 label: "a",
730 groups: vec![
731 (2, "192.0.2.20:4433", Source::System),
732 (1, "192.0.2.10:4433", Source::System),
733 ],
734 }))
735 .with_candidate_resolver(Arc::new(CandidateSetResolver {
736 label: "b",
737 groups: vec![
738 (2, "192.0.2.21:4433", Source::Dht),
739 (3, "192.0.2.30:4433", Source::Dht),
740 ],
741 }));
742
743 let candidates = resolvers
744 .lookup_endpoint_candidates(
745 "demo.dhttp.net",
746 crate::resolvers::endpoint_candidates::EndpointLookup::all(),
747 )
748 .await
749 .expect("candidate lookup succeeds");
750
751 let sequences = candidates
752 .groups
753 .iter()
754 .map(|group| group.chain.sequence().get())
755 .collect::<Vec<_>>();
756 assert_eq!(sequences, vec![2, 1, 3]);
757 assert_eq!(candidates.groups[0].endpoints.len(), 2);
758 assert_eq!(
759 candidates.groups[0].sources,
760 vec![Source::System, Source::Dht]
761 );
762 }
763
764 #[cfg(feature = "resolvers")]
765 #[test]
766 fn dns_scheme_round_trips_supported_schemes_and_rejects_dht() {
767 let cases = [
768 ("mdns", DnsScheme::Mdns),
769 ("http", DnsScheme::Http),
770 ("h3", DnsScheme::H3),
771 ("system", DnsScheme::System),
772 ];
773
774 for (text, scheme) in cases {
775 assert_eq!(DnsScheme::from_str(text).expect("supported scheme"), scheme);
776 assert_eq!(scheme.to_string(), text);
777 }
778
779 assert!(DnsScheme::from_str("dht").is_err());
780 }
781
782 #[cfg(feature = "resolvers")]
783 #[test]
784 fn resolvers_error_renders_no_resolvers_available_when_empty() {
785 let error = ResolversError { errors: vec![] };
786
787 assert_eq!(error.to_string(), "no DNS resolvers available");
788 }
789
790 #[cfg(feature = "resolvers")]
791 #[test]
792 fn resolvers_error_renders_resolver_bullets_in_stored_order() {
793 let error = ResolversError {
794 errors: vec![
795 (
796 "System DNS Resolver".to_string(),
797 other_error("invalid socket address"),
798 ),
799 ("mDNS resolvers".to_string(), other_error("timed out")),
800 ],
801 };
802
803 assert_eq!(
804 error.to_string(),
805 concat!(
806 "all DNS resolvers failed\n",
807 " - System DNS Resolver: invalid socket address\n",
808 " - mDNS resolvers: timed out"
809 )
810 );
811 }
812
813 #[cfg(feature = "resolvers")]
814 #[test]
815 fn resolvers_error_renders_numbered_source_chain_for_one_resolver() {
816 let error = ResolversError {
817 errors: vec![(
818 "DeferredResolver(H3 DNS Resolver(https://dns.genmeta.net:4433/))".to_string(),
819 chained_other_error(TestSourceError::with_source(
820 "deferred resolver lookup failed",
821 TestSourceError::leaf("no DNS record found"),
822 )),
823 )],
824 };
825
826 assert_eq!(
827 error.to_string(),
828 concat!(
829 "all DNS resolvers failed\n",
830 " - DeferredResolver(H3 DNS Resolver(https://dns.genmeta.net:4433/)): deferred resolver lookup failed\n",
831 " 1. no DNS record found"
832 )
833 );
834 }
835
836 #[cfg(feature = "resolvers")]
837 #[test]
838 fn resolvers_error_renders_repeated_source_messages_without_deduplication() {
839 let error = ResolversError {
840 errors: vec![(
841 "DeferredResolver(H3 DNS Resolver(https://dns.genmeta.net:4433/))".to_string(),
842 chained_other_error(TestSourceError::with_source(
843 "deferred resolver lookup failed",
844 TestSourceError::with_source(
845 "deferred resolver lookup failed",
846 TestSourceError::leaf("no DNS record found"),
847 ),
848 )),
849 )],
850 };
851
852 assert_eq!(
853 error.to_string(),
854 concat!(
855 "all DNS resolvers failed\n",
856 " - DeferredResolver(H3 DNS Resolver(https://dns.genmeta.net:4433/)): deferred resolver lookup failed\n",
857 " 1. deferred resolver lookup failed\n",
858 " 2. no DNS record found"
859 )
860 );
861 }
862
863 #[cfg(all(feature = "mdns", feature = "dquic-network", feature = "resolvers"))]
864 #[tokio::test]
865 async fn resolvers_builder_can_enable_mdns() {
866 use std::sync::Arc;
867
868 use h3x::dquic::{Network, binds::BindPattern};
869
870 let network = Network::builder().build();
871 let pattern = BindPattern::from_str("iface://v4.lo:0").expect("valid pattern");
872
873 let resolvers = Resolvers::builder()
874 .mdns(network, Arc::new(vec![pattern]))
875 .await
876 .build();
877
878 assert!(resolvers.to_string().contains("mDNS resolvers"));
879 }
880
881 #[cfg(all(feature = "h3", feature = "resolvers", feature = "dquic-network"))]
882 #[tokio::test]
883 async fn resolvers_builder_accepts_custom_h3_base_url() {
884 use std::sync::Arc;
885
886 let endpoint = Arc::new(h3x::endpoint::H3Endpoint::new(
887 h3x::dquic::QuicEndpoint::builder().build().await,
888 ));
889
890 let resolvers = Resolvers::builder()
891 .h3_with_base_url("https://custom-dns.example:4433", endpoint)
892 .expect("valid h3 dns url")
893 .build();
894
895 assert!(resolvers.to_string().contains("custom-dns.example"));
896 }
897
898 #[cfg(all(feature = "http", feature = "resolvers"))]
899 #[test]
900 fn resolvers_builder_accepts_custom_http_base_url() {
901 let resolvers = Resolvers::builder()
902 .http_with_base_url("https://custom-dns.example")
903 .expect("valid http dns url")
904 .build();
905
906 assert!(resolvers.to_string().contains("custom-dns.example"));
907 }
908
909 #[cfg(all(feature = "mdns", feature = "dquic-network", feature = "resolvers"))]
910 #[tokio::test]
911 async fn mdns_resolvers_bind_installs_mdns_on_null_io_binding() {
912 use std::sync::Arc;
913
914 use dquic::qinterface::io::IO;
915 use h3x::dquic::{Network, binds::BindPattern};
916
917 let network = Network::builder().build();
918 let pattern = BindPattern::from_str("iface://v4.lo:0").expect("valid pattern");
919 let resolvers = MdnsResolvers::bind(
920 network.clone(),
921 Arc::new(vec![pattern.clone()]),
922 DHTTP_MDNS_SERVICE,
923 )
924 .await;
925
926 let ifaces = resolvers
927 .bound_interfaces(&pattern)
928 .expect("bound interfaces");
929 if ifaces.is_empty() {
930 return;
931 }
932 assert!(ifaces[0].borrow().bound_addr().is_err());
933 assert!(
934 ifaces[0]
935 .with_components(|components, _| components.exist::<crate::mdns::service::Mdns>())
936 );
937 }
938}