use std::fmt;
use std::sync::Arc;
use tracing::Instrument;
use crate::api::ApiRequest;
use crate::config::{Config, common_builder_methods, request_span};
use crate::credentials::Credentials;
use crate::error::Error;
use crate::operations::{operation_table, resource_handles};
#[cfg(feature = "reqwest")]
use crate::transport::ReqwestTransport;
use crate::transport::Transport;
#[cfg(feature = "reqwest")]
pub struct Client<T = ReqwestTransport> {
inner: Arc<Inner<T>>,
}
#[cfg(not(feature = "reqwest"))]
pub struct Client<T> {
inner: Arc<Inner<T>>,
}
struct Inner<T> {
transport: T,
config: Config,
}
#[cfg(feature = "reqwest")]
impl Client {
pub fn new(credentials: Credentials) -> Self {
Self::builder(credentials).build()
}
pub fn builder(credentials: Credentials) -> ClientBuilder {
ClientBuilder::new(credentials, ReqwestTransport::default())
}
}
impl<T: Transport> Client<T> {
pub fn with_transport(credentials: Credentials, transport: T) -> Self {
ClientBuilder::new(credentials, transport).build()
}
pub fn transport(&self) -> &T {
&self.inner.transport
}
pub async fn execute<R: ApiRequest + Sync>(&self, request: &R) -> Result<R::Response, Error> {
let config = &self.inner.config;
async move {
let body = config.encode(request)?;
let response = self.inner.transport.send(config.http_request(body)).await?;
config.decode::<R>(response.status, &response.body)
}
.instrument(request_span::<R>())
.await
}
}
impl<T> Clone for Client<T> {
fn clone(&self) -> Self {
Self {
inner: Arc::clone(&self.inner),
}
}
}
impl<T> fmt::Debug for Client<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Client")
.field("config", &self.inner.config)
.finish_non_exhaustive()
}
}
#[cfg(feature = "reqwest")]
#[must_use]
pub struct ClientBuilder<T = ReqwestTransport> {
config: Config,
transport: T,
}
#[cfg(not(feature = "reqwest"))]
#[must_use]
pub struct ClientBuilder<T> {
config: Config,
transport: T,
}
impl<T> ClientBuilder<T> {
pub fn new(credentials: Credentials, transport: T) -> Self {
Self {
config: Config::new(credentials),
transport,
}
}
common_builder_methods!();
}
impl<T: Transport> ClientBuilder<T> {
pub fn build(self) -> Client<T> {
Client {
inner: Arc::new(Inner {
transport: self.transport,
config: self.config,
}),
}
}
}
impl<T> fmt::Debug for ClientBuilder<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ClientBuilder")
.field("config", &self.config)
.finish_non_exhaustive()
}
}
operation_table!(resource_handles, Client, Transport, async);