use crate::api::error::NetError;
use crate::api::http::http_request_method::HttpRequestMethod;
use crate::api::http::http_request_trait::HttpRequestTrait;
use crate::api::http::http_response::HttpResponseResult;
use crate::api::http::retry::{RetryPolicy, RetrySetting};
use async_trait::async_trait;
use bytes::Bytes;
use http::{HeaderMap, HeaderName, HeaderValue, Method};
#[derive(Clone, Debug)]
pub struct HttpRequest {
pub method: Method,
pub path: String,
pub headers: HeaderMap,
pub body: Bytes,
pub retry_policy: RetryPolicy,
pub(crate) retry_setting: RetrySetting,
}
pub struct HttpRequestBuilder {
method: Method,
path: String,
headers: HeaderMap,
body: Bytes,
retry_policy: RetryPolicy,
retry_setting: RetrySetting,
}
impl HttpRequest {
pub fn builder() -> HttpRequestBuilder {
HttpRequestBuilder {
method: Method::GET,
path: String::new(),
headers: HeaderMap::new(),
body: Bytes::new(),
retry_policy: RetryPolicy::no_retry(),
retry_setting: RetrySetting::Inherit,
}
}
pub(crate) fn retry_setting(&self) -> RetrySetting {
match &self.retry_setting {
RetrySetting::Inherit if self.retry_policy == RetryPolicy::no_retry() => {
RetrySetting::Inherit
}
RetrySetting::Inherit | RetrySetting::Policy(_) => {
RetrySetting::Policy(self.retry_policy.clone())
}
RetrySetting::None => RetrySetting::None,
}
}
}
impl HttpRequestBuilder {
pub fn method(mut self, method: impl Into<Method>) -> Self {
self.method = method.into();
self
}
pub fn path(mut self, path: impl Into<String>) -> Self {
self.path = path.into();
self
}
pub fn headers(mut self, headers: HeaderMap) -> Self {
self.headers = headers;
self
}
pub fn body(mut self, body: Bytes) -> Self {
self.body = body;
self
}
pub fn retry_policy(mut self, policy: RetryPolicy) -> Self {
self.retry_policy = policy;
self.retry_setting = RetrySetting::Policy(self.retry_policy.clone());
self
}
pub fn retry_setting(mut self, setting: RetrySetting) -> Self {
self.retry_setting = setting.clone();
self.retry_policy = match setting {
RetrySetting::Policy(policy) => policy,
RetrySetting::Inherit | RetrySetting::None => RetryPolicy::no_retry(),
};
self
}
pub fn header(
mut self,
name: impl TryInto<HeaderName>,
value: impl TryInto<HeaderValue>,
) -> Result<Self, NetError> {
let name = name
.try_into()
.map_err(|_| NetError::input("header", "invalid name"))?;
let value = value
.try_into()
.map_err(|_| NetError::input("header", "invalid value"))?;
self.headers.insert(name, value);
Ok(self)
}
pub fn build(self) -> Result<HttpRequest, NetError> {
if self.path.is_empty() {
return Err(NetError::input("path", "path must not be empty"));
}
Ok(HttpRequest {
method: self.method,
path: self.path,
headers: self.headers,
body: self.body,
retry_policy: self.retry_policy,
retry_setting: self.retry_setting,
})
}
}
#[async_trait]
impl HttpRequestTrait for HttpRequest {
fn get_path(&self) -> String {
self.path.clone()
}
fn get_method(&self) -> HttpRequestMethod {
self.method.clone().into()
}
fn get_req_body(&self) -> Bytes {
self.body.clone()
}
fn headers(&self) -> HeaderMap {
self.headers.clone()
}
fn retry_policy(&self) -> RetryPolicy {
self.retry_policy.clone()
}
async fn deal_with_response(self: Box<Self>, _result: HttpResponseResult) {}
}