use std::fmt;
use std::sync::Arc;
use std::time::Duration;
use http::header::{HeaderMap, HeaderValue, ACCEPT, AUTHORIZATION};
use zeroize::Zeroizing;
use crate::client::{Client, Inner, API_KEY, TRACEPARENT, USER_AGENT};
use crate::error::Error;
use crate::retry::RetryPolicy;
use crate::transport::{ReqwestTransport, Transport};
use crate::SecretString;
#[derive(Debug, Clone, Default, PartialEq, Eq)]
#[non_exhaustive]
pub enum Traceparent {
#[default]
Off,
Auto,
Fixed(String),
}
#[derive(Clone)]
#[must_use]
pub struct ClientBuilder {
pub(crate) base_url: String,
pub(crate) api_key: Option<SecretString>,
pub(crate) token: Option<SecretString>,
pub(crate) timeout: Duration,
pub(crate) deadline: Option<Duration>,
pub(crate) retry: RetryPolicy,
pub(crate) traceparent: Traceparent,
pub(crate) transport: Option<Arc<dyn Transport>>,
}
impl ClientBuilder {
pub fn api_key(mut self, key: impl Into<SecretString>) -> Self {
self.api_key = Some(key.into());
self
}
pub fn token(mut self, token: impl Into<SecretString>) -> Self {
self.token = Some(token.into());
self
}
pub fn timeout(mut self, timeout: Duration) -> Self {
self.timeout = timeout;
self
}
pub fn deadline(mut self, deadline: Duration) -> Self {
self.deadline = Some(deadline);
self
}
pub fn retry(mut self, policy: RetryPolicy) -> Self {
self.retry = policy;
self
}
pub fn traceparent(mut self, traceparent: Traceparent) -> Self {
self.traceparent = traceparent;
self
}
pub fn transport(mut self, transport: Arc<dyn Transport>) -> Self {
self.transport = Some(transport);
self
}
pub fn build(self) -> Result<Client, Error> {
let base_url = check_base_url(&self.base_url)?;
let headers = self.headers()?;
let auto_traceparent = self.traceparent == Traceparent::Auto;
let (timeout, deadline, retry) = (self.timeout, self.deadline, self.retry);
self.transport
.map_or_else(default_transport, Ok)
.map(|transport| Client {
inner: Arc::new(Inner {
base_url,
headers,
timeout,
deadline,
retry,
auto_traceparent,
transport,
}),
})
}
pub(crate) fn headers(&self) -> Result<HeaderMap, Error> {
let mut headers = HeaderMap::new();
headers.insert(
http::header::USER_AGENT,
HeaderValue::from_static(USER_AGENT),
);
headers.insert(
ACCEPT,
HeaderValue::from_static("application/json, application/problem+json"),
);
if let Some(key) = &self.api_key {
headers.insert(API_KEY, secret_header(key.expose_secret())?);
}
if let Some(token) = &self.token {
let bearer = Zeroizing::new(format!("Bearer {}", token.expose_secret()));
headers.insert(AUTHORIZATION, secret_header(&bearer)?);
}
if let Traceparent::Fixed(value) = &self.traceparent {
let value = HeaderValue::from_str(value.trim())
.map_err(|_| Error::Config("traceparent is not a valid header value"))?;
if !value.is_empty() {
headers.insert(TRACEPARENT, value);
}
}
Ok(headers)
}
}
fn default_transport() -> Result<Arc<dyn Transport>, Error> {
ReqwestTransport::new().map(|transport| Arc::new(transport) as Arc<dyn Transport>)
}
fn secret_header(value: &str) -> Result<HeaderValue, Error> {
let mut header = HeaderValue::from_str(value)
.map_err(|_| Error::Config("a credential is not a valid header value"))?;
header.set_sensitive(true);
Ok(header)
}
fn check_base_url(base_url: &str) -> Result<String, Error> {
let url = reqwest::Url::parse(base_url)
.map_err(|_| Error::Config("the base URL is not an absolute URL"))?;
if !matches!(url.scheme(), "http" | "https") {
return Err(Error::Config("the base URL is not http or https"));
}
if !url.username().is_empty() || url.password().is_some() {
return Err(Error::Config("the base URL carries credentials"));
}
if url.query().is_some() || url.fragment().is_some() {
return Err(Error::Config("the base URL has a query or fragment"));
}
Ok(base_url.trim_end_matches('/').to_owned())
}
impl fmt::Debug for ClientBuilder {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ClientBuilder")
.field("base_url", &self.base_url)
.field("api_key", &self.api_key.as_ref().map(|_| "<redacted>"))
.field("token", &self.token.as_ref().map(|_| "<redacted>"))
.field("timeout", &self.timeout)
.field("deadline", &self.deadline)
.field("retry", &self.retry)
.field("traceparent", &self.traceparent)
.finish_non_exhaustive()
}
}