use std::{fmt, sync::Arc};
use axum::{
Router,
body::{Body, to_bytes},
extract::{DefaultBodyLimit, MatchedPath},
http::{Request, StatusCode},
middleware::{self, Next},
response::IntoResponse,
};
use tower_http::{
compression::CompressionLayer,
cors::{AllowOrigin, CorsLayer},
timeout::TimeoutLayer,
trace::TraceLayer,
};
use tracing::Level;
use crate::http::{
ApiProblem, EndpointAuth, EndpointContractRegistry, EndpointIdempotency, EndpointMethod,
EndpointRateLimit, EndpointRouteRegistration, HttpAuthenticationHook, HttpMetricsLayer,
IdempotencyLayer, IdempotencyRequestPolicy, IdempotencyRuntime, IdempotencyStore, ProblemCode,
RateLimitKeySource, RateLimitLayer, RateLimitRuntime, RateLimitStore,
ReconciledEndpointContracts, RequestContext, request_context_middleware_with_forwarded_policy,
};
use super::{
error::HttpLayerError,
policy::{CorsPolicy, HttpLayerConfig, HttpRequestPolicy, RequestBodyLimitPolicy},
};
#[derive(Clone)]
#[non_exhaustive]
pub struct HttpFoundation {
config: HttpLayerConfig,
rate_limit: Option<RateLimitRuntime>,
idempotency: Option<IdempotencyRuntime>,
metrics: Option<HttpMetricsLayer>,
authentication: Option<Arc<dyn HttpAuthenticationHook>>,
}
impl fmt::Debug for HttpFoundation {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("HttpFoundation")
.field("config", &self.config)
.field("rate_limit", &self.rate_limit)
.field("idempotency", &self.idempotency)
.field("metrics", &self.metrics)
.field("authentication", &self.authentication.is_some())
.finish()
}
}
impl HttpFoundation {
#[must_use]
pub fn builder(config: HttpLayerConfig) -> HttpFoundationBuilder {
HttpFoundationBuilder::new(config)
}
#[must_use]
pub const fn config(&self) -> &HttpLayerConfig {
&self.config
}
pub fn apply<S>(self, router: Router<S>) -> Router<S>
where
S: Clone + Send + Sync + 'static,
{
apply_http_layers(router, self)
}
}
#[derive(Clone)]
#[non_exhaustive]
pub struct HttpFoundationBuilder {
config: HttpLayerConfig,
rate_limit_store: Option<Arc<dyn RateLimitStore>>,
idempotency_store: Option<Arc<dyn IdempotencyStore>>,
metrics: Option<Arc<dyn crate::observability::MetricRecorder>>,
authentication: Option<Arc<dyn HttpAuthenticationHook>>,
endpoint_contracts: Option<ReconciledEndpointContracts>,
}
impl fmt::Debug for HttpFoundationBuilder {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("HttpFoundationBuilder")
.field("config", &self.config)
.field("rate_limit_store", &self.rate_limit_store.is_some())
.field("idempotency_store", &self.idempotency_store.is_some())
.field("metrics", &self.metrics.is_some())
.field("authentication", &self.authentication.is_some())
.field("endpoint_contracts", &self.endpoint_contracts.is_some())
.finish()
}
}
impl HttpFoundationBuilder {
#[must_use]
pub fn new(config: HttpLayerConfig) -> Self {
Self {
config,
rate_limit_store: None,
idempotency_store: None,
metrics: None,
authentication: None,
endpoint_contracts: None,
}
}
#[must_use]
pub fn with_rate_limit_store(mut self, store: Arc<dyn RateLimitStore>) -> Self {
self.rate_limit_store = Some(store);
self
}
#[must_use]
pub fn with_idempotency_store(mut self, store: Arc<dyn IdempotencyStore>) -> Self {
self.idempotency_store = Some(store);
self
}
#[must_use]
pub fn with_metrics(mut self, metrics: Arc<dyn crate::observability::MetricRecorder>) -> Self {
self.metrics = Some(metrics);
self
}
#[must_use]
pub fn with_authentication_hook(
mut self,
authentication: Arc<dyn HttpAuthenticationHook>,
) -> Self {
self.authentication = Some(authentication);
self
}
#[must_use]
pub fn with_endpoint_contracts(
mut self,
endpoint_contracts: ReconciledEndpointContracts,
) -> Self {
self.endpoint_contracts = Some(endpoint_contracts);
self
}
pub fn reconcile_endpoint_contracts<P: Copy + 'static>(
self,
registry: &EndpointContractRegistry<'_, P>,
routes: &[EndpointRouteRegistration],
) -> Result<Self, HttpLayerError> {
Ok(self.with_endpoint_contracts(registry.reconcile_routes(routes)?))
}
pub fn build(self) -> Result<HttpFoundation, HttpLayerError> {
if let Some(endpoint_contracts) = &self.endpoint_contracts {
validate_endpoint_contract_policies(
&self.config,
endpoint_contracts,
self.authentication.is_some(),
)?;
}
if self
.config
.rate_limit
.as_ref()
.is_some_and(|policy| matches!(policy.key_source, RateLimitKeySource::PrincipalId))
&& self.authentication.is_none()
{
return Err(HttpLayerError::MissingAuthenticationHook);
}
let rate_limit = match (&self.config.rate_limit, self.rate_limit_store) {
(Some(policy), Some(store)) => Some(
RateLimitRuntime::new(policy.limiter, policy.key_source.clone(), store)
.with_metrics(self.metrics.clone()),
),
(Some(_), None) => return Err(HttpLayerError::MissingRateLimitStore),
(None, _) => None,
};
let idempotency = match (self.config.idempotency, self.idempotency_store) {
(Some(policy), Some(store)) => {
Some(IdempotencyRuntime::new(store, policy).with_metrics(self.metrics.clone()))
}
(Some(_), None) => return Err(HttpLayerError::MissingIdempotencyStore),
(None, _) => None,
};
let metrics = self.metrics.map(HttpMetricsLayer::new);
Ok(HttpFoundation {
config: self.config,
rate_limit,
idempotency,
metrics,
authentication: self.authentication,
})
}
}
fn validate_endpoint_contract_policies(
config: &HttpLayerConfig,
endpoint_contracts: &ReconciledEndpointContracts,
has_authentication: bool,
) -> Result<(), HttpLayerError> {
for endpoint in endpoint_contracts.policies() {
let method = endpoint_method(endpoint.method);
let effective = config
.request_policy
.policy_for_route(&method, endpoint.path.as_str());
let rate_limit_enabled = config.rate_limit.is_some() && effective.rate_limit().enabled();
let expected_rate_limit = endpoint.rate_limit != EndpointRateLimit::Exempt;
if rate_limit_enabled != expected_rate_limit {
return Err(HttpLayerError::EndpointContractRateLimitMismatch {
method: endpoint.method,
path: endpoint.path.as_str(),
expected_enabled: expected_rate_limit,
actual_enabled: rate_limit_enabled,
});
}
let actual_idempotency = if config.idempotency.is_some() {
effective.idempotency()
} else {
IdempotencyRequestPolicy::Disabled
};
let expected_idempotency = match endpoint.idempotency {
EndpointIdempotency::NotApplicable => IdempotencyRequestPolicy::Disabled,
EndpointIdempotency::Optional => IdempotencyRequestPolicy::HeaderOptional,
EndpointIdempotency::Required => IdempotencyRequestPolicy::Required,
};
if actual_idempotency != expected_idempotency {
return Err(HttpLayerError::EndpointContractIdempotencyMismatch {
method: endpoint.method,
path: endpoint.path.as_str(),
expected: endpoint.idempotency,
actual: actual_idempotency,
});
}
if endpoint.auth.requires_identity() && !has_authentication {
return Err(HttpLayerError::EndpointContractAuthenticationRequired {
method: endpoint.method,
path: endpoint.path.as_str(),
});
}
if rate_limit_enabled
&& endpoint.auth == EndpointAuth::Public
&& config
.rate_limit
.as_ref()
.is_some_and(|policy| matches!(policy.key_source, RateLimitKeySource::PrincipalId))
{
return Err(HttpLayerError::PublicEndpointPrincipalRateLimit {
method: endpoint.method,
path: endpoint.path.as_str(),
});
}
}
Ok(())
}
fn endpoint_method(method: EndpointMethod) -> axum::http::Method {
match method {
EndpointMethod::Delete => axum::http::Method::DELETE,
EndpointMethod::Get => axum::http::Method::GET,
EndpointMethod::Head => axum::http::Method::HEAD,
EndpointMethod::Options => axum::http::Method::OPTIONS,
EndpointMethod::Patch => axum::http::Method::PATCH,
EndpointMethod::Post => axum::http::Method::POST,
EndpointMethod::Put => axum::http::Method::PUT,
}
}
fn apply_http_layers<S>(router: Router<S>, foundation: HttpFoundation) -> Router<S>
where
S: Clone + Send + Sync + 'static,
{
let HttpFoundation {
config,
rate_limit,
idempotency,
metrics,
authentication,
} = foundation;
let default_request_body_limit = config.request_body_limit_policy();
let mut router = router.layer(DefaultBodyLimit::disable());
if let Some(rate_limit) = rate_limit {
router = router.layer(
RateLimitLayer::new(rate_limit).with_request_policy(config.request_policy.clone()),
);
}
if let Some(idempotency) = idempotency {
router = router.layer(
IdempotencyLayer::new(idempotency).with_request_policy(config.request_policy.clone()),
);
}
if config.compression {
router = router.layer(CompressionLayer::new());
}
if !matches!(default_request_body_limit, RequestBodyLimitPolicy::Disabled)
|| config.request_policy.has_request_body_limit_overrides()
{
router = router.layer(RouteRequestBodyLimitLayer::new(
config.request_policy.clone(),
default_request_body_limit,
));
}
if let Some(authentication) = authentication {
router = router.layer(middleware::from_fn(
move |request: Request<Body>, next: Next| {
let authentication = authentication.clone();
async move {
let context = request
.extensions()
.get::<RequestContext>()
.cloned()
.unwrap_or_else(|| RequestContext::from_headers(request.headers()));
let (parts, body) = request.into_parts();
match authentication.authenticate(&parts).await {
Ok(Some(verified)) => {
let mut request = Request::from_parts(parts, body);
verified.install(&mut request);
next.run(request).await
}
Ok(None) => next.run(Request::from_parts(parts, body)).await,
Err(problem) => problem.with_request_context(&context).into_response(),
}
}
},
));
}
if let Some(timeout) = config.timeout {
router = router.layer(TimeoutLayer::with_status_code(
StatusCode::REQUEST_TIMEOUT,
timeout,
));
}
if config.trace {
router = router.layer(TraceLayer::new_for_http().make_span_with(
|request: &axum::http::Request<_>| {
let context = request
.extensions()
.get::<RequestContext>()
.cloned()
.unwrap_or_else(|| RequestContext::from_headers(request.headers()));
let matched_path = request
.extensions()
.get::<MatchedPath>()
.map(MatchedPath::as_str)
.unwrap_or(crate::http::HTTP_METRICS_UNMATCHED_ROUTE);
tracing::span!(
Level::INFO,
"http_request",
method = %request.method(),
matched_path,
request_id = %context.request_id(),
trace_id = context.trace_id().unwrap_or_default()
)
},
));
}
if config.request_context {
let forwarded_headers = config.forwarded_headers;
router = router.layer(middleware::from_fn(move |request, next| {
request_context_middleware_with_forwarded_policy(
request,
next,
forwarded_headers.clone(),
)
}));
}
if let Some(cors_layer) = cors_layer(config.cors) {
router = router.layer(cors_layer);
}
if let Some(security_headers) = config.security_headers {
router = router.layer(middleware::from_fn(
move |request: Request<Body>, next: Next| {
let security_headers = security_headers.clone();
async move {
let mut response = next.run(request).await;
security_headers.apply(response.headers_mut());
response
}
},
));
}
if let Some(metrics) = metrics {
router = router.layer(metrics);
}
router
}
#[derive(Debug, Clone)]
struct RouteRequestBodyLimitLayer {
request_policy: HttpRequestPolicy,
default_request_body_limit: RequestBodyLimitPolicy,
}
impl RouteRequestBodyLimitLayer {
fn new(
request_policy: HttpRequestPolicy,
default_request_body_limit: RequestBodyLimitPolicy,
) -> Self {
Self {
request_policy,
default_request_body_limit,
}
}
}
impl<S> tower::Layer<S> for RouteRequestBodyLimitLayer {
type Service = RouteRequestBodyLimitService<S>;
fn layer(&self, inner: S) -> Self::Service {
RouteRequestBodyLimitService {
inner,
request_policy: self.request_policy.clone(),
default_request_body_limit: self.default_request_body_limit,
}
}
}
#[derive(Debug, Clone)]
struct RouteRequestBodyLimitService<S> {
inner: S,
request_policy: HttpRequestPolicy,
default_request_body_limit: RequestBodyLimitPolicy,
}
impl<S> tower::Service<Request<Body>> for RouteRequestBodyLimitService<S>
where
S: tower::Service<Request<Body>, Response = axum::response::Response> + Clone + Send + 'static,
S::Future: Send + 'static,
S::Error: Send + 'static,
{
type Response = axum::response::Response;
type Error = S::Error;
type Future = std::pin::Pin<
Box<dyn std::future::Future<Output = Result<Self::Response, Self::Error>> + Send>,
>;
fn poll_ready(
&mut self,
context: &mut std::task::Context<'_>,
) -> std::task::Poll<Result<(), Self::Error>> {
self.inner.poll_ready(context)
}
fn call(&mut self, request: Request<Body>) -> Self::Future {
let request_policy = self.request_policy.clone();
let default_request_body_limit = self.default_request_body_limit;
let clone = self.inner.clone();
let mut inner = std::mem::replace(&mut self.inner, clone);
Box::pin(async move {
match enforce_route_request_body_limit(
request_policy,
default_request_body_limit,
request,
)
.await
{
std::ops::ControlFlow::Continue(request) => inner.call(request).await,
std::ops::ControlFlow::Break(response) => Ok(response),
}
})
}
}
async fn enforce_route_request_body_limit(
request_policy: HttpRequestPolicy,
default_request_body_limit: RequestBodyLimitPolicy,
request: Request<Body>,
) -> std::ops::ControlFlow<axum::response::Response, Request<Body>> {
let RequestBodyLimitPolicy::Bytes(limit) =
request_policy.request_body_limit_for(&request, default_request_body_limit)
else {
return std::ops::ControlFlow::Continue(request);
};
let (parts, body) = request.into_parts();
let body = match to_bytes(body, limit.get()).await {
Ok(body) => body,
Err(_) => {
return std::ops::ControlFlow::Break(
ApiProblem::payload_too_large(
ProblemCode::REQUEST_BODY_TOO_LARGE,
"request body is too large",
)
.into_response(),
);
}
};
std::ops::ControlFlow::Continue(Request::from_parts(parts, Body::from(body)))
}
fn cors_layer(policy: CorsPolicy) -> Option<CorsLayer> {
match policy {
CorsPolicy::Disabled => None,
CorsPolicy::Permissive => Some(CorsLayer::permissive()),
CorsPolicy::Restricted(config) => {
let mut layer = CorsLayer::new()
.allow_origin(AllowOrigin::list(config.allowed_origins))
.allow_credentials(config.allow_credentials);
if !config.allowed_methods.is_empty() {
layer = layer.allow_methods(config.allowed_methods);
}
if !config.allowed_headers.is_empty() {
layer = layer.allow_headers(config.allowed_headers);
}
if !config.exposed_headers.is_empty() {
layer = layer.expose_headers(config.exposed_headers);
}
if let Some(max_age) = config.max_age {
layer = layer.max_age(max_age);
}
Some(layer)
}
}
}