use std::net::SocketAddr;
use std::sync::Arc;
use bytes::Bytes;
use crate::timeout::Timeout;
use crate::trace::TraceObserver;
#[derive(Clone, PartialEq, Eq)]
pub struct ResolvedTarget {
addresses: Arc<[SocketAddr]>,
}
impl ResolvedTarget {
pub fn new<I>(addresses: I) -> crate::Result<Self>
where
I: IntoIterator<Item = SocketAddr>,
{
let addresses: Vec<_> = addresses.into_iter().collect();
if addresses.is_empty() {
return Err(crate::Error::InvalidResolvedTarget(
"resolved destination set must not be empty".into(),
));
}
Ok(Self {
addresses: addresses.into(),
})
}
#[must_use]
pub fn addresses(&self) -> &[SocketAddr] {
&self.addresses
}
pub(crate) fn addresses_shared(&self) -> Arc<[SocketAddr]> {
Arc::clone(&self.addresses)
}
}
impl std::fmt::Debug for ResolvedTarget {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ResolvedTarget")
.field("address_count", &self.addresses.len())
.finish()
}
}
#[derive(Default, Clone)]
pub struct TransportHints {
pub target: Option<Bytes>,
pub sni_hostname: Option<String>,
pub resolved_target: Option<ResolvedTarget>,
pub trace: Option<Arc<dyn TraceObserver>>,
}
impl std::fmt::Debug for TransportHints {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let target = self.target.as_ref().map(bytes::Bytes::len);
f.debug_struct("TransportHints")
.field("target_len", &target)
.field("sni_hostname", &self.sni_hostname)
.field("resolved_target", &self.resolved_target)
.field("trace", &self.trace.as_ref().map(|_| "..."))
.finish()
}
}
#[derive(Default, Clone)]
pub struct NativeRequestOptions {
pub timeout: Option<Timeout>,
pub transport_hints: TransportHints,
}
impl std::fmt::Debug for NativeRequestOptions {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("NativeRequestOptions")
.field("timeout", &self.timeout)
.field("transport_hints", &self.transport_hints)
.finish()
}
}
impl NativeRequestOptions {
#[must_use]
pub fn timeout(mut self, timeout: Timeout) -> Self {
self.timeout = Some(timeout);
self
}
#[must_use]
pub fn transport_hints(mut self, transport_hints: TransportHints) -> Self {
self.transport_hints = transport_hints;
self
}
}