use crate::context::tenant::TENANT;
use crate::context::token_extract::extract_token_from_headers;
use crate::error::GarrisonError;
use crate::stp::with_current_token;
use actix_web::body::{BoxBody, EitherBody};
use actix_web::dev::{forward_ready, Service, ServiceRequest, ServiceResponse, Transform};
use actix_web::ResponseError;
use std::future::{ready, Ready};
use std::pin::Pin;
use std::rc::Rc;
use super::{GarrisonMiddleware, GarrisonMiddlewareService};
fn actix_headers_to_http(headers: &actix_web::http::header::HeaderMap) -> http::HeaderMap {
let mut out = http::HeaderMap::new();
for (name, value) in headers.iter() {
let Ok(value_str) = value.to_str() else {
continue;
};
let Ok(name) = http::HeaderName::from_bytes(name.as_str().as_bytes()) else {
continue;
};
if let Ok(value) = http::HeaderValue::from_str(value_str) {
out.append(name, value);
}
}
out
}
fn normalize_route_path(path: &str) -> &str {
if path.len() > 1 {
path.trim_end_matches('/')
} else {
path
}
}
fn route_matches_rule(pattern: &str, path: &str) -> bool {
let pattern = normalize_route_path(pattern);
let path = normalize_route_path(path);
let mut p = pattern.split('/');
let mut s = path.split('/');
loop {
match (p.next(), s.next()) {
(None, None) => return true,
(Some(seg), None) => return seg == "*" || seg == "{*wildcard}" || is_wild_brace(seg),
(Some(seg), Some(part)) => {
if seg == "*" || seg == "{*wildcard}" || is_wild_brace(seg) {
return true;
}
if is_param_segment(seg) {
if part.is_empty() {
return false;
}
} else if seg != part {
return false;
}
},
(None, Some(_)) => return false,
}
}
}
fn is_param_segment(seg: &str) -> bool {
seg.starts_with(':') || (seg.starts_with('{') && seg.ends_with('}') && seg.len() > 2)
}
fn is_wild_brace(seg: &str) -> bool {
seg.len() > 3 && seg.starts_with("{*") && seg.ends_with('}')
}
impl<S, B> Transform<S, ServiceRequest> for GarrisonMiddleware
where
S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = actix_web::Error> + 'static,
S::Future: 'static,
B: 'static,
{
type Response = ServiceResponse<EitherBody<B, BoxBody>>;
type Error = actix_web::Error;
type Transform = GarrisonMiddlewareService<S>;
type InitError = ();
type Future = Ready<Result<Self::Transform, Self::InitError>>;
fn new_transform(&self, service: S) -> Self::Future {
ready(Ok(GarrisonMiddlewareService {
inner: Rc::new(service),
rules: self.rules.clone(),
interceptor: self.interceptor.clone(),
config: self.config.clone(),
tenant_resolver: self.tenant_resolver.clone(),
handler_timeout: self.handler_timeout,
}))
}
}
impl<S, B> Service<ServiceRequest> for GarrisonMiddlewareService<S>
where
S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = actix_web::Error> + 'static,
S::Future: 'static,
B: 'static,
{
type Response = ServiceResponse<EitherBody<B, BoxBody>>;
type Error = actix_web::Error;
type Future = Pin<Box<dyn std::future::Future<Output = Result<Self::Response, Self::Error>>>>;
forward_ready!(inner);
fn call(&self, req: ServiceRequest) -> Self::Future {
let interceptor = self.interceptor.clone();
let path = req.uri().path().to_string();
let headers = req.headers().clone();
let rule_annotation = self
.rules
.iter()
.find(|(pattern, _)| route_matches_rule(pattern, &path))
.map(|(_, annotation)| annotation.clone());
let token = extract_token_from_headers(&headers, &self.config)
.ok()
.flatten();
let tenant_resolver = self.tenant_resolver.clone();
let inner = self.inner.clone();
let handler_timeout = self.handler_timeout;
Box::pin(async move {
let auth_check = async move {
if let Some(annotation) = rule_annotation {
interceptor.pre_handle(&path, &annotation).await?;
}
Ok::<_, GarrisonError>(())
};
let auth_result: Result<(), GarrisonError> = async {
let tenant_ctx = match &tenant_resolver {
Some(resolver) => {
let http_headers = actix_headers_to_http(&headers);
Some(resolver.resolve(&http_headers).await?)
},
None => None,
};
match (tenant_ctx, token) {
(Some(ctx), Some(t)) => {
TENANT
.scope(ctx, async move { with_current_token(t, auth_check).await })
.await
},
(Some(ctx), None) => TENANT.scope(ctx, auth_check).await,
(None, Some(t)) => with_current_token(t, auth_check).await,
(None, None) => auth_check.await,
}
}
.await;
match auth_result {
Ok(()) => {
let result = match handler_timeout {
Some(timeout) => {
match tokio::time::timeout(timeout, (*inner).call(req)).await {
Ok(res) => res,
Err(_elapsed) => {
tracing::warn!(
timeout_secs = timeout.as_secs_f64(),
"garrison middleware: inner handler timed out"
);
return Err(actix_web::error::ErrorGatewayTimeout(
"gateway timeout",
));
},
}
},
None => (*inner).call(req).await,
};
let res = result?;
Ok(res.map_into_left_body())
},
Err(e) => {
tracing::error!(error = ?e, "garrison middleware rejection");
let resp = e.error_response();
Ok(req.into_response(resp).map_into_right_body())
},
}
})
}
}
#[cfg(test)]
mod route_match_tests {
use super::*;
#[test]
fn route_matches_rule_exact() {
assert!(route_matches_rule("/api/users", "/api/users"));
assert!(!route_matches_rule("/api/users", "/api/other"));
assert!(route_matches_rule("/api/users", "/api/users/"));
assert!(route_matches_rule("/api/users/", "/api/users"));
}
#[test]
fn route_matches_rule_param_segment() {
assert!(route_matches_rule("/api/users/{id}", "/api/users/42"));
assert!(route_matches_rule("/api/users/:id", "/api/users/42"));
assert!(!route_matches_rule("/api/users/{id}", "/api/users/"));
assert!(!route_matches_rule(
"/api/users/{id}",
"/api/users/42/extra"
));
}
#[test]
fn route_matches_rule_wildcard_suffix() {
assert!(route_matches_rule("/api/*", "/api"));
assert!(route_matches_rule("/api/*", "/api/users/42"));
assert!(route_matches_rule("/api/users/{*rest}", "/api/users/a/b"));
assert!(!route_matches_rule("/api/users/{*rest}", "/api/others/x"));
}
#[test]
fn route_matches_rule_mixed() {
assert!(route_matches_rule(
"/api/{version}/users/:id",
"/api/v1/users/42"
));
assert!(!route_matches_rule(
"/api/{version}/users/:id",
"/api/v1/items/42"
));
}
}