use crate::error::{GarrisonError, GarrisonResult};
use crate::manager::GarrisonManager;
use crate::stp::mfa::MfaLogic;
use crate::stp::permission::PermissionLogic;
use crate::stp::session::SessionLogic;
use crate::stp::with_current_token;
use async_trait::async_trait;
use super::types::{LoginParams, SessionData, TokenInfo};
use super::AuthBackend;
pub struct BackendEmbedded;
impl BackendEmbedded {
pub fn new() -> Self {
Self
}
}
impl Default for BackendEmbedded {
fn default() -> Self {
Self::new()
}
}
#[async_trait]
impl AuthBackend for BackendEmbedded {
#[tracing::instrument(skip_all, fields(login_id = %login_id))]
async fn login(&self, login_id: &str, params: &LoginParams) -> GarrisonResult<String> {
let logic = GarrisonManager::logic()?;
logic.login(login_id, params).await
}
#[tracing::instrument(skip_all)]
async fn logout(&self, token: &str) -> GarrisonResult<()> {
let logic = GarrisonManager::logic()?;
with_current_token(token.to_string(), async { logic.logout().await }).await
}
#[tracing::instrument(skip_all)]
async fn check_login(&self, token: &str) -> GarrisonResult<bool> {
let logic = GarrisonManager::logic()?;
with_current_token(token.to_string(), async { logic.check_login().await }).await
}
async fn check_permission(&self, token: &str, permission: &str) -> GarrisonResult<()> {
let logic = GarrisonManager::logic()?;
let perm = permission.to_string();
with_current_token(token.to_string(), async move {
logic.check_permission(&perm).await
})
.await
}
async fn check_role(&self, token: &str, role: &str) -> GarrisonResult<()> {
let logic = GarrisonManager::logic()?;
let role = role.to_string();
with_current_token(
token.to_string(),
async move { logic.check_role(&role).await },
)
.await
}
async fn check_safe(&self, token: &str) -> GarrisonResult<bool> {
let logic = GarrisonManager::logic()?;
with_current_token(token.to_string(), async {
match logic.check_safe().await {
Ok(()) => Ok(true),
Err(GarrisonError::NotSafe { .. }) => Ok(false),
Err(e) => Err(e),
}
})
.await
}
async fn check_disable(&self, token: &str) -> GarrisonResult<bool> {
let logic = GarrisonManager::logic()?;
with_current_token(token.to_string(), async {
match logic.check_disable().await {
Ok(()) => Ok(false),
Err(GarrisonError::DisableService { .. }) => Ok(true),
Err(e) => Err(e),
}
})
.await
}
async fn check_api_key(&self, api_key: &str, namespace: &str) -> GarrisonResult<()> {
let logic = GarrisonManager::logic()?;
let ns = namespace.to_string();
with_current_token(api_key.to_string(), async move {
logic.check_api_key(&ns).await
})
.await
}
async fn get_token_info(&self, token: &str) -> GarrisonResult<TokenInfo> {
let logic = GarrisonManager::logic()?;
let ts = logic
.session
.get_token_session(token)
.await?
.ok_or_else(|| {
GarrisonError::InvalidToken("backend-token-invalid-or-expired::".to_string())
})?;
Ok(TokenInfo {
token: ts.token,
created_at: ts.created_at,
last_active_at: ts.last_active_at,
})
}
async fn get_session(&self, token: &str) -> GarrisonResult<SessionData> {
let logic = GarrisonManager::logic()?;
logic
.session
.get_token_session(token)
.await?
.ok_or_else(|| {
GarrisonError::InvalidToken("backend-token-invalid-or-expired::".to_string())
})
}
async fn kickout(&self, login_id: &str) -> GarrisonResult<()> {
let logic = GarrisonManager::logic()?;
logic.kickout(login_id).await
}
async fn switch_to(&self, token: &str, target_login_id: &str) -> GarrisonResult<()> {
let logic = GarrisonManager::logic()?;
let auth_logic = logic.auth_logic.as_ref().ok_or_else(|| {
GarrisonError::NotImplemented("backend-auth-logic-not-injected::".to_string())
})?;
auth_logic.switch_to(token, target_login_id).await
}
#[tracing::instrument(skip_all)]
async fn renew_to_equivalent(&self, token: &str) -> GarrisonResult<String> {
let logic = GarrisonManager::logic()?;
let auth_logic = logic.auth_logic.as_ref().ok_or_else(|| {
GarrisonError::NotImplemented("backend-auth-logic-not-injected-renew::".to_string())
})?;
auth_logic.renew_to_equivalent(token).await
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::GarrisonConfig;
use crate::dao::GarrisonDao;
use crate::stp::mock::{MockDao, MockInterface};
use crate::stp::GarrisonInterface;
use serial_test::serial;
use std::sync::Arc;
async fn setup_backend() -> BackendEmbedded {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let mut config = GarrisonConfig::default_config();
config.timeout = 3600;
config.active_timeout = -1;
config.throw_on_not_login = false;
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface);
GarrisonManager::builder()
.dao(dao)
.config(Arc::new(config))
.interface(interface)
.build()
.await
.unwrap();
BackendEmbedded::new()
}
#[tokio::test]
#[serial]
async fn test_login_returns_token() {
let backend = setup_backend().await;
let token = backend
.login("user1", &LoginParams::default())
.await
.unwrap();
assert!(!token.is_empty());
}
#[tokio::test]
#[serial]
async fn test_check_login_valid_token() {
let backend = setup_backend().await;
let token = backend
.login("user1", &LoginParams::default())
.await
.unwrap();
assert!(backend.check_login(&token).await.unwrap());
}
#[tokio::test]
#[serial]
async fn test_check_login_invalid_token() {
let backend = setup_backend().await;
assert!(!backend.check_login("invalid-token").await.unwrap());
}
#[tokio::test]
#[serial]
async fn test_logout_invalidates_token() {
let backend = setup_backend().await;
let token = backend
.login("user1", &LoginParams::default())
.await
.unwrap();
backend.logout(&token).await.unwrap();
assert!(!backend.check_login(&token).await.unwrap());
}
#[tokio::test]
#[serial]
async fn test_kickout_invalidates_all_sessions() {
let backend = setup_backend().await;
let t1 = backend
.login("user1", &LoginParams::default())
.await
.unwrap();
let t2 = backend
.login("user1", &LoginParams::default())
.await
.unwrap();
backend.kickout("user1").await.unwrap();
assert!(!backend.check_login(&t1).await.unwrap());
assert!(!backend.check_login(&t2).await.unwrap());
}
#[tokio::test]
#[serial]
async fn test_get_token_info() {
let backend = setup_backend().await;
let token = backend
.login("user1", &LoginParams::default())
.await
.unwrap();
let info = backend.get_token_info(&token).await.unwrap();
assert_eq!(info.token, token);
assert!(info.created_at > 0);
assert!(info.last_active_at >= info.created_at);
}
#[tokio::test]
#[serial]
async fn test_get_token_info_invalid_token() {
let backend = setup_backend().await;
let result = backend.get_token_info("invalid").await;
assert!(result.is_err());
match result.unwrap_err() {
GarrisonError::InvalidToken(_) => {},
e => panic!("期望 InvalidToken,实际: {:?}", e),
}
}
#[tokio::test]
#[serial]
async fn test_get_session() {
let backend = setup_backend().await;
let token = backend
.login("user1", &LoginParams::default())
.await
.unwrap();
let session = backend.get_session(&token).await.unwrap();
assert_eq!(session.token, token);
assert_eq!(session.login_id, "user1");
}
#[tokio::test]
#[serial]
async fn test_get_session_invalid_token() {
let backend = setup_backend().await;
let result = backend.get_session("invalid").await;
assert!(result.is_err());
}
#[cfg(feature = "security-extra")]
#[tokio::test]
#[serial]
async fn test_check_safe_default_returns_false() {
let backend = setup_backend().await;
let token = backend
.login("user1", &LoginParams::default())
.await
.unwrap();
assert!(!backend.check_safe(&token).await.unwrap());
}
#[tokio::test]
#[serial]
async fn test_check_disable_default_returns_false() {
let backend = setup_backend().await;
let token = backend
.login("user1", &LoginParams::default())
.await
.unwrap();
assert!(!backend.check_disable(&token).await.unwrap());
}
#[tokio::test]
#[serial]
async fn test_check_safe_forged_token_returns_session_error() {
let backend = setup_backend().await;
let result = backend
.check_safe("00000000-0000-0000-0000-000000000000")
.await;
assert!(
matches!(result, Err(GarrisonError::Session(_))),
"伪造 token 的 check_safe 应返回 Err(Session),实际: {:?}",
result
);
}
#[tokio::test]
#[serial]
async fn test_check_safe_kicked_out_token_returns_session_error() {
let backend = setup_backend().await;
let token = backend
.login("safe-kick-user", &LoginParams::default())
.await
.unwrap();
backend.kickout("safe-kick-user").await.unwrap();
let result = backend.check_safe(&token).await;
assert!(
matches!(result, Err(GarrisonError::Session(_))),
"kickout 后旧 token 的 check_safe 应返回 Err(Session),实际: {:?}",
result
);
}
#[tokio::test]
#[serial]
async fn test_check_disable_forged_token_returns_session_error() {
let backend = setup_backend().await;
let result = backend
.check_disable("00000000-0000-0000-0000-000000000000")
.await;
assert!(
matches!(result, Err(GarrisonError::Session(_))),
"伪造 token 的 check_disable 应返回 Err(Session),实际: {:?}",
result
);
}
#[tokio::test]
#[serial]
async fn test_check_disable_kicked_out_token_returns_session_error() {
let backend = setup_backend().await;
let token = backend
.login("disable-kick-user", &LoginParams::default())
.await
.unwrap();
backend.kickout("disable-kick-user").await.unwrap();
let result = backend.check_disable(&token).await;
assert!(
matches!(result, Err(GarrisonError::Session(_))),
"kickout 后旧 token 的 check_disable 应返回 Err(Session),实际: {:?}",
result
);
}
#[tokio::test]
#[serial]
async fn test_switch_to_default_guard_denies() {
let backend = setup_backend().await;
let token = backend
.login("user1", &LoginParams::default())
.await
.unwrap();
let _ = backend
.login("user2", &LoginParams::default())
.await
.unwrap();
let result = backend.switch_to(&token, "user2").await;
assert!(result.is_err());
match result.unwrap_err() {
GarrisonError::NotPermission(_) => {},
e => panic!("期望 NotPermission,实际: {:?}", e),
}
}
#[tokio::test]
#[serial]
async fn test_renew_to_equivalent_returns_new_token() {
let backend = setup_backend().await;
let old_token = backend
.login("user1", &LoginParams::default())
.await
.unwrap();
let new_token = backend.renew_to_equivalent(&old_token).await.unwrap();
assert_ne!(old_token, new_token);
assert!(!backend.check_login(&old_token).await.unwrap());
assert!(backend.check_login(&new_token).await.unwrap());
}
#[tokio::test]
#[serial]
async fn test_check_permission_invalid_token() {
let backend = setup_backend().await;
let result = backend.check_permission("invalid", "user:read").await;
assert!(result.is_err());
}
#[tokio::test]
#[serial]
async fn test_dyn_dispatch_with_backend_embedded() {
let backend: Arc<dyn AuthBackend> = Arc::new(setup_backend().await);
let token = backend
.login("dyn-user", &LoginParams::default())
.await
.unwrap();
assert!(backend.check_login(&token).await.unwrap());
}
use std::sync::Mutex;
use tracing::span::Attributes;
use tracing::{Id, Metadata, Subscriber};
#[derive(Default)]
struct SpanNameCollector {
names: Arc<Mutex<Vec<&'static str>>>,
}
impl Subscriber for SpanNameCollector {
fn enabled(&self, _metadata: &Metadata<'_>) -> bool {
true
}
fn new_span(&self, span: &Attributes<'_>) -> Id {
self.names.lock().unwrap().push(span.metadata().name());
Id::from_u64(1)
}
fn record(&self, _span: &Id, _values: &tracing::span::Record<'_>) {}
fn record_follows_from(&self, _span: &Id, _follows: &Id) {}
fn event(&self, _event: &tracing::Event<'_>) {}
fn enter(&self, _span: &Id) {}
fn exit(&self, _span: &Id) {}
}
#[tokio::test(flavor = "current_thread")]
#[serial]
async fn test_login_creates_tracing_span() {
let backend = setup_backend().await;
let names = Arc::new(Mutex::new(Vec::new()));
let _guard = tracing::subscriber::set_default(SpanNameCollector {
names: names.clone(),
});
let _ = backend.login("span-user", &LoginParams::default()).await;
assert!(
names.lock().unwrap().contains(&"login"),
"login 应创建名为 'login' 的 tracing span,实际捕获: {:?}",
names.lock().unwrap()
);
}
#[tokio::test(flavor = "current_thread")]
#[serial]
async fn test_logout_creates_tracing_span() {
let backend = setup_backend().await;
let token = backend
.login("span-user", &LoginParams::default())
.await
.unwrap();
let names = Arc::new(Mutex::new(Vec::new()));
let _guard = tracing::subscriber::set_default(SpanNameCollector {
names: names.clone(),
});
let _ = backend.logout(&token).await;
assert!(
names.lock().unwrap().contains(&"logout"),
"logout 应创建名为 'logout' 的 tracing span,实际捕获: {:?}",
names.lock().unwrap()
);
}
#[tokio::test(flavor = "current_thread")]
#[serial]
async fn test_check_login_creates_tracing_span() {
let backend = setup_backend().await;
let token = backend
.login("span-user", &LoginParams::default())
.await
.unwrap();
let names = Arc::new(Mutex::new(Vec::new()));
let _guard = tracing::subscriber::set_default(SpanNameCollector {
names: names.clone(),
});
let _ = backend.check_login(&token).await;
assert!(
names.lock().unwrap().contains(&"check_login"),
"check_login 应创建名为 'check_login' 的 tracing span,实际捕获: {:?}",
names.lock().unwrap()
);
}
#[test]
fn backend_embedded_default_returns_instance() {
let _backend = BackendEmbedded;
}
#[tokio::test]
#[serial]
async fn test_check_role_invalid_token() {
let backend = setup_backend().await;
let result = backend.check_role("invalid-token", "admin").await;
assert!(result.is_err());
}
#[tokio::test]
#[serial]
async fn test_check_safe_no_security_extra_returns_true() {
let backend = setup_backend().await;
let token = backend
.login("safe-user", &LoginParams::default())
.await
.unwrap();
let result = backend.check_safe(&token).await;
assert!(result.is_ok(), "check_safe 应成功: {:?}", result);
}
#[tokio::test]
#[serial]
async fn test_check_api_key_invalid() {
let backend = setup_backend().await;
let result = backend.check_api_key("invalid-key", "default").await;
assert!(result.is_err());
}
#[tokio::test(flavor = "current_thread")]
#[serial]
async fn test_span_name_collector_record_and_follows() {
let backend = setup_backend().await;
let names = Arc::new(Mutex::new(Vec::new()));
let _guard = tracing::subscriber::set_default(SpanNameCollector {
names: names.clone(),
});
let _ = backend.login("record-user", &LoginParams::default()).await;
tracing::info!("test event to trigger record");
}
}