use crate::context::token_extract::extract_token_from_headers;
fn warn_missing_config_once() {
static WARN: std::sync::Once = std::sync::Once::new();
WARN.call_once(|| {
tracing::warn!(
"{}",
crate::i18n::translate_detail("logs-actix-config-not-registered", &[])
);
});
}
pub use crate::context::GarrisonPrincipal;
impl actix_web::FromRequest for GarrisonPrincipal {
type Error = crate::error::GarrisonError;
type Future = std::pin::Pin<Box<dyn std::future::Future<Output = Result<Self, Self::Error>>>>;
fn from_request(req: &actix_web::HttpRequest, _: &mut actix_web::dev::Payload) -> Self::Future {
let headers = req.headers().clone();
let config = req
.app_data::<actix_web::web::Data<std::sync::Arc<crate::config::GarrisonConfig>>>()
.map(|d| d.get_ref().clone())
.unwrap_or_else(|| {
warn_missing_config_once();
std::sync::Arc::new(crate::config::GarrisonConfig::default_config())
});
Box::pin(async move {
let token = extract_token_from_headers(&headers, &config)?.ok_or_else(|| {
crate::error::GarrisonError::NotLogin("web-not-login::".to_string())
})?;
let login_id = crate::stp::GarrisonUtil::get_login_id_by_token(&token)
.await?
.ok_or_else(|| {
crate::error::GarrisonError::NotLogin("web-token-invalid::".to_string())
})?;
Ok(GarrisonPrincipal { login_id })
})
}
}
impl actix_web::FromRequest for super::CheckLogin {
type Error = crate::error::GarrisonError;
type Future = std::pin::Pin<Box<dyn std::future::Future<Output = Result<Self, Self::Error>>>>;
fn from_request(req: &actix_web::HttpRequest, _: &mut actix_web::dev::Payload) -> Self::Future {
let headers = req.headers().clone();
let config = req
.app_data::<actix_web::web::Data<std::sync::Arc<crate::config::GarrisonConfig>>>()
.map(|d| d.get_ref().clone())
.unwrap_or_else(|| {
warn_missing_config_once();
std::sync::Arc::new(crate::config::GarrisonConfig::default_config())
});
Box::pin(async move {
let token = extract_token_from_headers(&headers, &config)?.ok_or_else(|| {
crate::error::GarrisonError::NotLogin("web-not-login::".to_string())
})?;
let result: crate::error::GarrisonResult<()> =
crate::stp::with_current_token(token, async {
let logged_in = crate::stp::GarrisonUtil::check_login().await?;
if !logged_in {
return Err(crate::error::GarrisonError::NotLogin(
"web-not-login::".to_string(),
));
}
Ok(())
})
.await;
result.map(|_| super::CheckLogin)
})
}
}
impl actix_web::FromRequest for super::CheckRole {
type Error = crate::error::GarrisonError;
type Future = std::pin::Pin<Box<dyn std::future::Future<Output = Result<Self, Self::Error>>>>;
fn from_request(req: &actix_web::HttpRequest, _: &mut actix_web::dev::Payload) -> Self::Future {
let headers = req.headers().clone();
let config = req
.app_data::<actix_web::web::Data<std::sync::Arc<crate::config::GarrisonConfig>>>()
.map(|d| d.get_ref().clone())
.unwrap_or_else(|| {
warn_missing_config_once();
std::sync::Arc::new(crate::config::GarrisonConfig::default_config())
});
let role = req
.app_data::<actix_web::web::Data<super::RequiredRole>>()
.map(|d| d.0.clone())
.unwrap_or_default();
Box::pin(async move {
let token = extract_token_from_headers(&headers, &config)?.ok_or_else(|| {
crate::error::GarrisonError::NotLogin("web-not-login::".to_string())
})?;
let result: crate::error::GarrisonResult<()> =
crate::stp::with_current_token(token, async {
crate::stp::GarrisonUtil::check_role(&role).await
})
.await;
result.map(|_| super::CheckRole(role))
})
}
}
impl actix_web::FromRequest for super::CheckPermission {
type Error = crate::error::GarrisonError;
type Future = std::pin::Pin<Box<dyn std::future::Future<Output = Result<Self, Self::Error>>>>;
fn from_request(req: &actix_web::HttpRequest, _: &mut actix_web::dev::Payload) -> Self::Future {
let headers = req.headers().clone();
let config = req
.app_data::<actix_web::web::Data<std::sync::Arc<crate::config::GarrisonConfig>>>()
.map(|d| d.get_ref().clone())
.unwrap_or_else(|| {
warn_missing_config_once();
std::sync::Arc::new(crate::config::GarrisonConfig::default_config())
});
let permission = req
.app_data::<actix_web::web::Data<super::RequiredPermission>>()
.map(|d| d.0.clone())
.unwrap_or_default();
Box::pin(async move {
let token = extract_token_from_headers(&headers, &config)?.ok_or_else(|| {
crate::error::GarrisonError::NotLogin("web-not-login::".to_string())
})?;
let result: crate::error::GarrisonResult<()> =
crate::stp::with_current_token(token, async {
crate::stp::GarrisonUtil::check_permission(&permission).await
})
.await;
result.map(|_| super::CheckPermission(permission))
})
}
}
#[cfg(feature = "tenant-isolation")]
fn warn_header_tenant_unverified_once() {
static WARN: std::sync::Once = std::sync::Once::new();
WARN.call_once(|| {
tracing::warn!(
"{}",
crate::i18n::translate_detail("logs-actix-tenant-header-unverified", &[])
);
});
}
#[cfg(feature = "tenant-isolation")]
impl actix_web::FromRequest for crate::context::tenant::TenantContext {
type Error = crate::error::GarrisonError;
type Future = std::pin::Pin<Box<dyn std::future::Future<Output = Result<Self, Self::Error>>>>;
fn from_request(req: &actix_web::HttpRequest, _: &mut actix_web::dev::Payload) -> Self::Future {
let headers = req.headers().clone();
warn_header_tenant_unverified_once();
Box::pin(async move {
let raw = headers
.get("x-tenant-id")
.and_then(|v| v.to_str().ok())
.ok_or_else(|| {
crate::error::GarrisonError::Config("ctx-tenant-id-missing::".into())
})?;
let tenant_id: i64 = raw.parse().map_err(|_| {
crate::error::GarrisonError::Config(format!("ctx-tenant-id-invalid::{}", raw))
})?;
Ok(crate::context::tenant::TenantContext {
tenant_id,
resolved_from: crate::context::tenant::TenantSource::Header,
})
})
}
}
#[cfg(test)]
mod tests {
use super::super::mock::{MockDao, MockInterface};
use super::*;
use crate::dao::GarrisonDao;
use crate::manager::GarrisonManager;
use crate::stp::{GarrisonInterface, GarrisonUtil};
use actix_web::test;
use actix_web::FromRequest;
use serial_test::serial;
fn make_config() -> crate::config::GarrisonConfig {
let mut config = crate::config::GarrisonConfig::default_config();
config.timeout = 3600;
config.active_timeout = -1;
config.throw_on_not_login = false;
config
}
async fn init_manager() {
GarrisonManager::reset_for_test();
let dao: std::sync::Arc<dyn GarrisonDao> = std::sync::Arc::new(MockDao::new());
let config = std::sync::Arc::new(make_config());
let interface: std::sync::Arc<dyn GarrisonInterface> =
std::sync::Arc::new(MockInterface::new());
GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await
.unwrap();
}
#[tokio::test]
#[serial]
async fn garrison_principal_extracted_from_actix_request() {
init_manager().await;
let login_id = "1001";
let token = GarrisonUtil::login_simple(login_id).await.unwrap();
let req = test::TestRequest::get()
.uri("/api/test")
.insert_header(("Authorization", format!("Bearer {}", token)))
.to_http_request();
let mut payload = actix_web::dev::Payload::None;
let principal = GarrisonPrincipal::from_request(&req, &mut payload)
.await
.expect("GarrisonPrincipal::from_request 应成功解析 token");
assert_eq!(principal.login_id, login_id);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn garrison_principal_returns_err_without_token() {
init_manager().await;
let req = test::TestRequest::get().uri("/api/test").to_http_request();
let mut payload = actix_web::dev::Payload::None;
let result = GarrisonPrincipal::from_request(&req, &mut payload).await;
assert!(
result.is_err(),
"无 token 时 from_request 应返回 Err,实际 = {:?}",
result
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn garrison_principal_returns_err_with_invalid_token() {
init_manager().await;
let req = test::TestRequest::get()
.uri("/api/test")
.insert_header(("Authorization", "Bearer invalid_token_xyz"))
.to_http_request();
let mut payload = actix_web::dev::Payload::None;
let result = GarrisonPrincipal::from_request(&req, &mut payload).await;
assert!(
result.is_err(),
"无效 token 时 from_request 应返回 Err,实际 = {:?}",
result
);
GarrisonManager::reset_for_test();
}
}
#[cfg(all(test, feature = "tenant-isolation"))]
mod tenant_tests {
use crate::context::tenant::{TenantContext, TenantSource};
use actix_web::test;
use actix_web::FromRequest;
use serial_test::serial;
#[tokio::test]
#[serial]
async fn tenant_context_extracted_from_actix_request_when_tenant_isolation_enabled() {
let req = test::TestRequest::get()
.uri("/api/test")
.insert_header(("X-Tenant-Id", "42"))
.to_http_request();
let mut payload = actix_web::dev::Payload::None;
let ctx = TenantContext::from_request(&req, &mut payload)
.await
.expect("TenantContext::from_request 应成功解析 X-Tenant-Id header");
assert_eq!(ctx.tenant_id, 42);
assert_eq!(ctx.resolved_from, TenantSource::Header);
}
#[tokio::test]
#[serial]
async fn tenant_context_returns_err_without_x_tenant_id_header() {
let req = test::TestRequest::get().uri("/api/test").to_http_request();
let mut payload = actix_web::dev::Payload::None;
let result = TenantContext::from_request(&req, &mut payload).await;
assert!(
result.is_err(),
"无 X-Tenant-Id header 时 from_request 应返回 Err,实际 = {:?}",
result
);
}
#[tokio::test]
#[serial]
async fn tenant_context_returns_err_with_non_numeric_x_tenant_id() {
let req = test::TestRequest::get()
.uri("/api/test")
.insert_header(("X-Tenant-Id", "not_a_number"))
.to_http_request();
let mut payload = actix_web::dev::Payload::None;
let result = TenantContext::from_request(&req, &mut payload).await;
assert!(
result.is_err(),
"X-Tenant-Id 非数字时 from_request 应返回 Err,实际 = {:?}",
result
);
}
}