use std::time::Duration;
use serde::{Deserialize, Serialize};
use crate::{
http::{
DEFAULT_IDEMPOTENCY_MAX_BODY_BYTES, DEFAULT_IDEMPOTENCY_PROCESSING_TTL,
DEFAULT_IDEMPOTENCY_TTL, IdempotencyConfig,
},
settings::{SettingsIssues, SettingsValidationError},
};
use super::super::error::HttpMiddlewareError;
#[cfg_attr(feature = "tier", derive(tier::TierConfig))]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(default, deny_unknown_fields)]
#[non_exhaustive]
pub struct HttpIdempotencySettings {
pub enabled: bool,
#[serde(with = "crate::settings::human_duration")]
pub ttl: Duration,
#[serde(with = "crate::settings::human_duration")]
pub processing_ttl: Duration,
pub max_request_body_bytes: usize,
pub max_response_body_bytes: usize,
}
impl Default for HttpIdempotencySettings {
fn default() -> Self {
Self {
enabled: false,
ttl: DEFAULT_IDEMPOTENCY_TTL,
processing_ttl: DEFAULT_IDEMPOTENCY_PROCESSING_TTL,
max_request_body_bytes: DEFAULT_IDEMPOTENCY_MAX_BODY_BYTES,
max_response_body_bytes: DEFAULT_IDEMPOTENCY_MAX_BODY_BYTES,
}
}
}
impl HttpIdempotencySettings {
#[must_use]
pub const fn with_enabled(mut self, enabled: bool) -> Self {
self.enabled = enabled;
self
}
#[must_use]
pub const fn with_ttl(mut self, ttl: Duration) -> Self {
self.ttl = ttl;
self
}
#[must_use]
pub const fn with_processing_ttl(mut self, processing_ttl: Duration) -> Self {
self.processing_ttl = processing_ttl;
self
}
#[must_use]
pub const fn with_max_request_body_bytes(mut self, max_request_body_bytes: usize) -> Self {
self.max_request_body_bytes = max_request_body_bytes;
self
}
#[must_use]
pub const fn with_max_response_body_bytes(mut self, max_response_body_bytes: usize) -> Self {
self.max_response_body_bytes = max_response_body_bytes;
self
}
pub(in crate::http::layers) fn config(
&self,
) -> Result<Option<IdempotencyConfig>, HttpMiddlewareError> {
if !self.enabled {
return Ok(None);
}
IdempotencyConfig::new(
self.ttl,
self.processing_ttl,
self.max_request_body_bytes,
self.max_response_body_bytes,
)
.map(Some)
.map_err(|_| HttpMiddlewareError::InvalidIdempotencyConfig)
}
pub(crate) fn validate_at(&self, path: &str) -> Result<(), SettingsValidationError> {
let mut issues = SettingsIssues::new();
if self.enabled {
issues.require(
!self.ttl.is_zero(),
format!("{path}.ttl"),
"must be greater than zero when idempotency is enabled",
);
issues.require(
!self.processing_ttl.is_zero(),
format!("{path}.processing_ttl"),
"must be greater than zero when idempotency is enabled",
);
issues.require(
self.max_request_body_bytes > 0,
format!("{path}.max_request_body_bytes"),
"must be greater than zero when idempotency is enabled",
);
issues.require(
self.max_response_body_bytes > 0,
format!("{path}.max_response_body_bytes"),
"must be greater than zero when idempotency is enabled",
);
}
issues.into_result()
}
}