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()
}
}
pub(crate) const TARGET_NOT_UTF8_MESSAGE: &str = "target extension is not valid UTF-8";
pub(crate) fn target_extension_str(target: &[u8]) -> crate::Result<&str> {
std::str::from_utf8(target)
.map_err(|_| crate::Error::InvalidUrl(TARGET_NOT_UTF8_MESSAGE.into()))
}
#[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
}
}
#[cfg(test)]
mod tests {
use super::{target_extension_str, TARGET_NOT_UTF8_MESSAGE};
#[test]
fn target_extension_decodes_valid_utf8() {
assert_eq!(
target_extension_str(b"/absolute/path").expect("valid"),
"/absolute/path"
);
assert_eq!(target_extension_str(b"*").expect("valid"), "*");
}
#[test]
fn target_extension_rejects_non_utf8_with_the_shared_message() {
let error = target_extension_str(&[0xff, 0xfe]).expect_err("invalid UTF-8 must fail");
assert!(
matches!(&error, crate::Error::InvalidUrl(message) if message == TARGET_NOT_UTF8_MESSAGE),
"got {error:?}"
);
}
}