use crate::config::GarrisonConfig;
use crate::error::GarrisonResult;
#[cfg(any(
feature = "backend-embedded",
feature = "backend-remote",
feature = "listener"
))]
use crate::loc;
use crate::session::GarrisonSession;
use crate::stp::core::GarrisonCore;
use crate::stp::mfa::MfaLogic;
use crate::stp::permission::PermissionLogic;
use crate::stp::session::SessionLogic;
use crate::stp::token::TokenLogic;
use crate::stp::LoginParams;
use std::sync::Arc;
use std::time::Duration;
use tokio::runtime::Handle;
use tokio::task;
use tokio::task::JoinHandle;
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
#[derive(Clone)]
struct BackendHandle(Arc<dyn crate::backend::AuthBackend>);
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
static CURRENT_BACKEND: arc_swap::ArcSwapOption<BackendHandle> =
arc_swap::ArcSwapOption::const_empty();
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
pub fn init_backend(backend: Arc<dyn crate::backend::AuthBackend>) -> GarrisonResult<()> {
try_init_backend(&CURRENT_BACKEND, backend)
}
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
fn try_init_backend(
store: &arc_swap::ArcSwapOption<BackendHandle>,
backend: Arc<dyn crate::backend::AuthBackend>,
) -> GarrisonResult<()> {
let none: Option<std::sync::Arc<BackendHandle>> = None;
let previous = store.compare_and_swap(&none, Some(Arc::new(BackendHandle(backend))));
if previous.is_some() {
return Err(crate::error::GarrisonError::Config(
"stp-backend-already-init::".into(),
));
}
Ok(())
}
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
fn get_backend() -> GarrisonResult<Option<Arc<dyn crate::backend::AuthBackend>>> {
let guard = CURRENT_BACKEND.load();
if let Some(handle) = &*guard {
return Ok(Some(Arc::clone(&handle.0)));
}
#[cfg(not(feature = "backend-embedded"))]
{
Err(crate::error::GarrisonError::Config(
"stp-backend-not-init::".into(),
))
}
#[cfg(feature = "backend-embedded")]
{
Ok(None)
}
}
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
#[cfg(test)]
pub(crate) fn reset_backend_for_test() {
CURRENT_BACKEND.store(None);
}
#[cfg(all(test, feature = "backend-embedded"))]
mod backend_bridge_tests {
use super::*;
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn concurrent_init_exactly_one_wins() {
use std::sync::atomic::{AtomicUsize, Ordering};
let store = Arc::new(arc_swap::ArcSwapOption::const_empty());
let ok_count = Arc::new(AtomicUsize::new(0));
let mut handles = Vec::new();
for _ in 0..8 {
let store = Arc::clone(&store);
let ok_count = Arc::clone(&ok_count);
handles.push(tokio::spawn(async move {
if try_init_backend(
&store,
Arc::new(crate::backend::embedded::BackendEmbedded::new()),
)
.is_ok()
{
ok_count.fetch_add(1, Ordering::SeqCst);
}
}));
}
for h in handles {
h.await.unwrap();
}
assert_eq!(
ok_count.load(Ordering::SeqCst),
1,
"并发初始化应恰好一个成功(CAS 契约)"
);
assert!(store.load().is_some(), "初始化成功后 store 应持有后端实例");
let err = try_init_backend(
&store,
Arc::new(crate::backend::embedded::BackendEmbedded::new()),
)
.unwrap_err();
assert!(
matches!(err, crate::error::GarrisonError::Config(ref m) if m.contains("stp-backend-already-init")),
"重复初始化应返回 already-init Config 错误,实际: {:?}",
err
);
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum JwtMode {
Stateless,
#[default]
Mixin,
Simple,
}
pub struct GarrisonUtil;
impl GarrisonUtil {
pub async fn login(id: impl Into<String>, params: &LoginParams) -> GarrisonResult<String> {
let id: String = id.into();
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
return backend.login(&id, params).await;
}
}
crate::manager::GarrisonManager::logic()?
.login(&id, params)
.await
}
pub async fn login_simple(id: impl Into<String>) -> GarrisonResult<String> {
Self::login(id, &LoginParams::default()).await
}
pub async fn logout() -> GarrisonResult<()> {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
let token = super::current_token()?;
return backend.logout(&token).await;
}
}
crate::manager::GarrisonManager::logic()?.logout().await
}
pub async fn logout_by_login_id(login_id: impl Into<String>) -> GarrisonResult<()> {
let login_id: String = login_id.into();
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
return backend.kickout(&login_id).await;
}
}
crate::manager::GarrisonManager::logic()?
.logout_by_login_id(&login_id)
.await
}
pub async fn kickout(login_id: impl Into<String>) -> GarrisonResult<()> {
let login_id: String = login_id.into();
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
return backend.kickout(&login_id).await;
}
}
crate::manager::GarrisonManager::logic()?
.kickout(&login_id)
.await
}
pub async fn kickout_by_token(token: &str) -> GarrisonResult<()> {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
return backend.logout(token).await;
}
}
crate::manager::GarrisonManager::logic()?
.kickout_by_token(token)
.await
}
pub async fn invalidate_sessions_after_password_change(
login_id: impl Into<String>,
) -> GarrisonResult<()> {
let login_id: String = login_id.into();
let logic = crate::manager::GarrisonManager::logic()?;
logic.session.logout_by_login_id(&login_id).await?;
#[cfg(feature = "listener")]
if let Some(lm) = &logic.listener_manager {
lm.broadcast(&crate::listener::GarrisonEvent::Kickout {
login_id: login_id.clone(),
token: String::new(),
reason: loc!("session-kickout-password-changed", "password-changed"),
request_context: None,
})
.await;
}
Ok(())
}
pub async fn revoke_token(token: &str) -> GarrisonResult<()> {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
return backend.logout(token).await;
}
}
crate::manager::GarrisonManager::logic()?
.revoke_token(token)
.await
}
pub async fn check_login() -> GarrisonResult<bool> {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
let token = super::current_token()?;
return backend.check_login(&token).await;
}
}
crate::manager::GarrisonManager::logic()?
.check_login()
.await
}
pub async fn get_login_id() -> GarrisonResult<Option<String>> {
crate::manager::GarrisonManager::logic()?
.get_login_id()
.await
}
pub async fn get_login_id_by_token(token: &str) -> GarrisonResult<Option<String>> {
super::with_current_token(token.to_string(), async { Self::get_login_id().await }).await
}
pub async fn check_permission(permission: &str) -> GarrisonResult<()> {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
let token = super::current_token()?;
return backend.check_permission(&token, permission).await;
}
}
crate::manager::GarrisonManager::logic()?
.check_permission(permission)
.await
}
pub async fn check_role(role: &str) -> GarrisonResult<()> {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
let token = super::current_token()?;
return backend.check_role(&token, role).await;
}
}
crate::manager::GarrisonManager::logic()?
.check_role(role)
.await
}
pub async fn has_permission(permission: &str) -> GarrisonResult<bool> {
if permission.is_empty() {
return Err(crate::error::GarrisonError::InvalidParam(
"stp-permission-empty::".to_string(),
));
}
crate::manager::GarrisonManager::logic()?
.has_permission(permission)
.await
}
pub async fn has_role(role: &str) -> GarrisonResult<bool> {
if role.is_empty() {
return Err(crate::error::GarrisonError::InvalidParam(
"stp-role-empty::".to_string(),
));
}
crate::manager::GarrisonManager::logic()?
.has_role(role)
.await
}
pub async fn get_permission_list() -> GarrisonResult<Vec<String>> {
crate::manager::GarrisonManager::logic()?
.get_permission_list()
.await
}
pub async fn get_role_list() -> GarrisonResult<Vec<String>> {
crate::manager::GarrisonManager::logic()?
.get_role_list()
.await
}
pub async fn check_access_token() -> GarrisonResult<()> {
crate::manager::GarrisonManager::logic()?
.check_access_token()
.await
}
pub async fn check_client_token() -> GarrisonResult<()> {
crate::manager::GarrisonManager::logic()?
.check_client_token()
.await
}
pub async fn check_temp_token() -> GarrisonResult<()> {
crate::manager::GarrisonManager::logic()?
.check_temp_token()
.await
}
pub async fn check_safe() -> GarrisonResult<()> {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
let token = super::current_token()?;
let is_safe = backend.check_safe(&token).await?;
if is_safe {
return Ok(());
}
return Err(crate::error::GarrisonError::NotSafe {
reason: loc!("stp-mfa-not-passed", ""),
});
}
}
crate::manager::GarrisonManager::logic()?.check_safe().await
}
pub async fn check_disable() -> GarrisonResult<()> {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
let token = super::current_token()?;
let is_disabled = backend.check_disable(&token).await?;
if is_disabled {
return Err(crate::error::GarrisonError::DisableService {
service: "default".to_string(),
until: None,
});
}
return Ok(());
}
}
crate::manager::GarrisonManager::logic()?
.check_disable()
.await
}
pub async fn check_api_key(namespace: &str) -> GarrisonResult<()> {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
let token = super::current_token()?;
return backend.check_api_key(&token, namespace).await;
}
}
crate::manager::GarrisonManager::logic()?
.check_api_key(namespace)
.await
}
pub async fn login_by_token(token: &str) -> GarrisonResult<()> {
crate::manager::GarrisonManager::logic()?
.login_by_token(token)
.await
}
pub async fn verify_token(token: &str) -> GarrisonResult<String> {
crate::manager::GarrisonManager::logic()?
.verify_token(token)
.await
}
pub async fn refresh_token(token: &str) -> GarrisonResult<String> {
crate::manager::GarrisonManager::logic()?
.refresh_token(token)
.await
}
pub fn check_login_sync() -> GarrisonResult<bool> {
task::block_in_place(|| Handle::current().block_on(Self::check_login()))
}
pub fn check_permission_sync(perm: &str) -> GarrisonResult<()> {
let perm = perm.to_string();
task::block_in_place(|| Handle::current().block_on(Self::check_permission(&perm)))
}
pub fn check_role_sync(role: &str) -> GarrisonResult<()> {
let role = role.to_string();
task::block_in_place(|| Handle::current().block_on(Self::check_role(&role)))
}
pub fn check_access_token_sync() -> GarrisonResult<()> {
task::block_in_place(|| Handle::current().block_on(Self::check_access_token()))
}
pub fn check_client_token_sync() -> GarrisonResult<()> {
task::block_in_place(|| Handle::current().block_on(Self::check_client_token()))
}
pub fn check_temp_token_sync() -> GarrisonResult<()> {
task::block_in_place(|| Handle::current().block_on(Self::check_temp_token()))
}
pub fn check_api_key_sync(namespace: &str) -> GarrisonResult<()> {
let namespace = namespace.to_string();
task::block_in_place(|| Handle::current().block_on(Self::check_api_key(&namespace)))
}
pub fn check_safe_sync() -> GarrisonResult<()> {
task::block_in_place(|| Handle::current().block_on(Self::check_safe()))
}
pub fn check_disable_sync() -> GarrisonResult<()> {
task::block_in_place(|| Handle::current().block_on(Self::check_disable()))
}
pub fn config() -> GarrisonResult<Arc<GarrisonConfig>> {
Ok(crate::manager::GarrisonManager::logic()?.config())
}
}
pub fn spawn_cleanup_task(
session: Arc<GarrisonSession>,
interval_secs: i64,
) -> Option<JoinHandle<()>> {
if interval_secs <= 0 {
return None;
}
let interval_duration = Duration::from_secs(interval_secs as u64);
let handle = tokio::spawn(async move {
let mut interval = tokio::time::interval(interval_duration);
loop {
interval.tick().await;
if let Err(e) = session.cleanup_expired_tokens().await {
tracing::warn!("cleanup_expired_tokens failed: {}", e);
}
}
});
Some(handle)
}
#[cfg(test)]
mod tests;