use std::fmt;
use std::sync::Arc;
use std::time::Duration;
use http::header::{HeaderMap, HeaderName, HeaderValue, AUTHORIZATION, CONTENT_TYPE};
use http::Method;
use serde::de::DeserializeOwned;
use serde::Serialize;
use zeroize::Zeroizing;
use crate::builder::{ClientBuilder, Traceparent};
use crate::error::{ApiError, DecodeError, Error, Problem, TransportError};
use crate::retry::{is_idempotent, random, RetryPolicy};
use crate::transport::{HttpRequest, HttpResponse, Transport};
use crate::types::Envelope;
pub const DEFAULT_TIMEOUT: Duration = Duration::from_secs(30);
pub const VERSION: &str = env!("CARGO_PKG_VERSION");
pub const USER_AGENT: &str = concat!("crypto-service-sdk-rust/", env!("CARGO_PKG_VERSION"));
pub(crate) const TRACEPARENT: HeaderName = HeaderName::from_static("traceparent");
pub(crate) const API_KEY: HeaderName = HeaderName::from_static("x-api-key");
#[derive(Clone)]
pub struct Client {
pub(crate) inner: Arc<Inner>,
}
pub(crate) struct Inner {
pub(crate) base_url: String,
pub(crate) headers: HeaderMap,
pub(crate) timeout: Duration,
pub(crate) deadline: Option<Duration>,
pub(crate) retry: RetryPolicy,
pub(crate) auto_traceparent: bool,
pub(crate) transport: Arc<dyn Transport>,
}
impl fmt::Debug for Client {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let inner = &self.inner;
f.debug_struct("Client")
.field("base_url", &inner.base_url)
.field("api_key", &redacted(&inner.headers, &API_KEY))
.field("token", &redacted(&inner.headers, &AUTHORIZATION))
.field("timeout", &inner.timeout)
.field("deadline", &inner.deadline)
.field("retry", &inner.retry)
.field("transport", &inner.transport)
.finish_non_exhaustive()
}
}
fn redacted(headers: &HeaderMap, name: &HeaderName) -> Option<&'static str> {
headers.contains_key(name).then_some("<redacted>")
}
#[derive(Debug, Clone)]
pub struct RawRequest {
pub method: Method,
pub path: String,
pub body: Option<Vec<u8>>,
pub headers: HeaderMap,
}
impl RawRequest {
pub fn new(method: Method, path: impl Into<String>) -> Self {
RawRequest {
method,
path: path.into(),
body: None,
headers: HeaderMap::new(),
}
}
pub fn json<B: Serialize + ?Sized>(
method: Method,
path: impl Into<String>,
body: &B,
) -> Result<Self, Error> {
let mut request = Self::new(method, path);
encode(body).map(|bytes| {
request.body = Some(bytes);
request
})
}
}
impl Client {
pub fn builder(base_url: impl Into<String>) -> ClientBuilder {
ClientBuilder {
base_url: base_url.into(),
api_key: None,
token: None,
timeout: DEFAULT_TIMEOUT,
deadline: None,
retry: RetryPolicy::default(),
traceparent: Traceparent::Off,
transport: None,
}
}
pub fn new(base_url: impl Into<String>) -> Result<Self, Error> {
Self::builder(base_url).build()
}
#[must_use]
pub fn base_url(&self) -> &str {
&self.inner.base_url
}
pub async fn send_raw(&self, request: RawRequest) -> Result<HttpResponse, Error> {
let RawRequest {
method,
path,
body,
headers,
} = request;
self.exchange(method, &path, body, headers).await
}
pub(crate) async fn call<B, T>(
&self,
method: Method,
path: &str,
body: Option<&B>,
) -> Result<T, Error>
where
B: Serialize + ?Sized,
T: DeserializeOwned,
{
let body = body.map(encode).transpose();
self.send_encoded(method, path, body).await.and_then(decode)
}
pub(crate) async fn call_data<B, T>(
&self,
method: Method,
path: &str,
body: Option<&B>,
) -> Result<T, Error>
where
B: Serialize + ?Sized,
T: DeserializeOwned,
{
self.call::<B, Envelope<T>>(method, path, body)
.await
.map(Envelope::into_data)
}
async fn send_encoded(
&self,
method: Method,
path: &str,
body: Result<Option<Vec<u8>>, Error>,
) -> Result<HttpResponse, Error> {
match body {
Ok(body) => self.exchange(method, path, body, HeaderMap::new()).await,
Err(error) => Err(error),
}
}
async fn exchange(
&self,
method: Method,
path: &str,
body: Option<Vec<u8>>,
extra: HeaderMap,
) -> Result<HttpResponse, Error> {
let inner = &self.inner;
let idempotent = is_idempotent(&method, path);
let request = HttpRequest {
headers: self.request_headers(body.is_some(), extra),
method,
url: format!("{}{}", inner.base_url, path),
body,
};
let attempts = self.attempts(request, idempotent);
let outcome = match inner.deadline {
Some(deadline) => tokio::time::timeout(deadline, attempts)
.await
.unwrap_or_else(|_| Err(TransportError::deadline())),
None => attempts.await,
};
outcome.map_err(Error::from)
}
fn request_headers(&self, has_body: bool, extra: HeaderMap) -> HeaderMap {
let mut headers = self.inner.headers.clone();
if self.inner.auto_traceparent {
headers.insert(TRACEPARENT, traceparent());
}
if has_body {
headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
}
headers.extend(extra);
headers
}
async fn attempts(
&self,
request: HttpRequest,
idempotent: bool,
) -> Result<HttpResponse, TransportError> {
let policy = self.inner.retry;
if policy.get_max_retries() == 0 {
return self.attempt(request).await;
}
let mut retry = 1;
loop {
let outcome = self.attempt(request.clone()).await;
let wait = match &outcome {
Ok(response) => policy.after_status(
retry,
response.status,
response.header("retry-after"),
idempotent,
),
Err(_) => policy.after_failure(retry, idempotent),
};
match wait {
Some(wait) => tokio::time::sleep(wait).await,
None => return outcome,
}
retry += 1;
}
}
async fn attempt(&self, request: HttpRequest) -> Result<HttpResponse, TransportError> {
let send = self.inner.transport.send(request);
if self.inner.timeout.is_zero() {
return send.await;
}
tokio::time::timeout(self.inner.timeout, send)
.await
.unwrap_or_else(|_| Err(TransportError::attempt_timeout()))
}
}
fn traceparent() -> HeaderValue {
let value = format!(
"00-{:016x}{:016x}-{:016x}-01",
random() | 1,
random(),
random() | 1
);
HeaderValue::from_str(&value).unwrap_or(HeaderValue::from_static(
"00-00000000000000000000000000000001-0000000000000001-01",
))
}
pub(crate) fn encode<B: Serialize + ?Sized>(body: &B) -> Result<Vec<u8>, Error> {
serde_json::to_vec(body).map_err(decode_error)
}
pub(crate) fn decode<T: DeserializeOwned>(response: HttpResponse) -> Result<T, Error> {
success_body(response).and_then(|body| serde_json::from_slice(&body).map_err(decode_error))
}
fn success_body(response: HttpResponse) -> Result<Zeroizing<Vec<u8>>, Error> {
let status = response.status;
let body = Zeroizing::new(response.body);
if (200..300).contains(&status) {
return Ok(body);
}
Err(Error::from(ApiError {
status,
problem: Problem::from_body(status, &body),
}))
}
fn decode_error(error: serde_json::Error) -> Error {
Error::Decode(DecodeError::from(error))
}
#[cfg(test)]
mod tests;