use super::*;
impl GarrisonSession {
pub fn new(
dao: Arc<dyn GarrisonDao>,
timeout: u64,
active_timeout: u64,
remember_me_timeout: u64,
) -> Self {
Self {
dao,
timeout,
active_timeout,
remember_me_timeout,
#[cfg(feature = "session-extra")]
anon_session_timeout: crate::config::DEFAULT_ANON_SESSION_TIMEOUT_SECS,
login_locks: DashMap::new(),
token_session_locks: DashMap::new(),
login_token_map: DashMap::new(),
#[cfg(feature = "listener")]
listener_manager: None,
expiry_listeners: Vec::new(),
last_active_time: DashMap::new(),
}
}
pub(crate) fn dao(&self) -> &Arc<dyn GarrisonDao> {
&self.dao
}
#[cfg(feature = "listener")]
pub fn with_listener_manager(
mut self,
manager: Arc<crate::listener::GarrisonListenerManager>,
) -> Self {
self.listener_manager = Some(manager);
self
}
#[cfg(feature = "session-extra")]
pub fn with_anon_session_timeout(mut self, timeout: u64) -> Self {
self.anon_session_timeout = timeout;
self
}
pub fn add_expiry_listener(&mut self, listener: Arc<dyn SessionExpiryListener>) {
self.expiry_listeners.push(listener);
}
async fn trigger_expiry_listeners(&self, login_id: &str, token: &str) {
for listener in &self.expiry_listeners {
if let Err(e) = listener.on_session_expired(login_id, token).await {
let token_preview = token.get(..8).unwrap_or(token);
tracing::warn!(
"SessionExpiryListener callback failed (login_id={}, token={}...): {}",
login_id,
token_preview,
e
);
}
}
}
pub fn update_last_active(&self, login_id: &str) {
let now = chrono::Utc::now().timestamp_millis();
self.last_active_time.insert(login_id.to_string(), now);
}
pub fn update_last_active_at(&self, login_id: &str, timestamp_millis: i64) {
self.last_active_time
.insert(login_id.to_string(), timestamp_millis);
}
pub fn get_last_active(&self, login_id: &str) -> Option<i64> {
self.last_active_time.get(login_id).map(|v| *v)
}
pub fn check_hover_timeout(&self, login_id: &str, hover_timeout_secs: i64) -> bool {
if hover_timeout_secs <= 0 {
return true; }
let now = chrono::Utc::now().timestamp_millis();
let timeout_millis = hover_timeout_secs.saturating_mul(1000);
match self.last_active_time.get(login_id) {
Some(last) => {
let elapsed = now - *last;
if elapsed > timeout_millis {
return false; }
true
},
None => true, }
}
pub(crate) async fn with_login_lock<F, R>(&self, login_id: &str, f: F) -> R
where
F: std::future::Future<Output = R>,
{
let lock = self
.login_locks
.entry(login_id.to_string())
.or_insert_with(|| Arc::new(TokioMutex::new(())))
.clone();
let _guard = lock.lock().await;
f.await
}
pub(crate) async fn with_token_session_lock<F, R>(&self, token: &str, f: F) -> R
where
F: std::future::Future<Output = R>,
{
let lock = self
.token_session_locks
.entry(token.to_string())
.or_insert_with(|| Arc::new(TokioMutex::new(())))
.clone();
let _guard = lock.lock().await;
let result = f.await;
drop(_guard);
drop(lock);
self.token_session_locks
.remove_if(token, |_, l| Arc::strong_count(l) == 1);
result
}
pub async fn create(&self, login_id: impl Into<String>, token: &str) -> GarrisonResult<()> {
let login_id: String = login_id.into();
self.create_inner(&login_id, token, None, None, None, None)
.await
}
pub async fn create_with_seed_primary_amr(
&self,
login_id: impl Into<String>,
token: &str,
seed_primary_amr: bool,
) -> GarrisonResult<()> {
let login_id: String = login_id.into();
self.with_login_lock(&login_id, async {
self.create_token_session_inner(
&login_id,
token,
None,
None,
None,
None,
seed_primary_amr,
)
.await
})
.await
}
pub async fn create_token_session(
&self,
login_id: &str,
token: &str,
params: &crate::stp::LoginParams,
) -> GarrisonResult<()> {
self.create_inner(
login_id,
token,
params.device.as_deref(),
params.ip.as_deref(),
params.user_agent.as_deref(),
Some(params.remember_me),
)
.await
}
async fn create_inner(
&self,
login_id: &str,
token: &str,
device: Option<&str>,
ip: Option<&str>,
user_agent: Option<&str>,
remember_me: Option<bool>,
) -> GarrisonResult<()> {
let login_id: String = login_id.to_string();
self.with_login_lock(&login_id, async {
self.create_token_session_inner(
&login_id,
token,
device,
ip,
user_agent,
remember_me,
true,
)
.await
})
.await
}
pub(crate) async fn create_token_session_inner(
&self,
login_id: &str,
token: &str,
device: Option<&str>,
ip: Option<&str>,
user_agent: Option<&str>,
remember_me: Option<bool>,
seed_primary_amr: bool,
) -> GarrisonResult<()> {
let now = Utc::now().timestamp();
let (ttl, effective_timeout) = if remember_me == Some(true) {
(
self.remember_me_timeout,
Some(self.remember_me_timeout as i64),
)
} else {
(self.timeout, None)
};
let amr_ledger = if seed_primary_amr {
vec![crate::stp::mfa::AmrEntry::new(
crate::stp::mfa::PRIMARY_FACTOR_AMR,
crate::stp::mfa::PRIMARY_FACTOR_AAL,
now,
)
.map_err(|e| GarrisonError::Session(format!("session-sim-primary-amr::{:?}", e)))?]
} else {
Vec::new()
};
let mut token_session = TokenSession {
token: token.to_string(),
login_id: login_id.to_string(),
created_at: now,
last_active_at: now,
attrs: HashMap::new(),
device: device.map(|s| s.to_string()),
ip: ip.map(|s| s.to_string()),
user_agent: user_agent.map(|s| s.to_string()),
safe_services: HashMap::new(),
#[cfg(feature = "session-extra")]
dynamic_active_timeout: None,
#[cfg(feature = "session-extra")]
is_anon: false,
effective_timeout,
amr_ledger,
auth_time: if seed_primary_amr { Some(now) } else { None },
};
if let Ok(ctx) = crate::context::tenant::TENANT.try_get() {
token_session.attrs.insert(
crate::context::tenant::SESSION_TENANT_ATTR_KEY.to_string(),
ctx.tenant_id.to_string(),
);
}
let token_json = serde_json::to_string(&token_session)
.map_err(|e| GarrisonError::Session(format!("session-sim-token-serialize::{}", e)))?;
self.dao.set(&token_key(token), &token_json, ttl).await?;
let mut account = self
.get_account_session(login_id)
.await?
.unwrap_or_else(|| AccountSession {
login_id: login_id.to_string(),
tokens: vec![],
created_at: now,
last_active_at: now,
});
account.tokens.push(TokenInfo {
token: token.to_string(),
created_at: now,
last_active_at: now,
});
account.last_active_at = now;
let account_json = serde_json::to_string(&account)
.map_err(|e| GarrisonError::Session(format!("session-sim-account-serialize::{}", e)))?;
self.dao
.set(&account_key(login_id), &account_json, self.active_timeout)
.await?;
self.add_login_token(login_id, token);
Ok(())
}
async fn delete_token_session_if_still_expired(&self, token: &str) {
let json = match self.dao.get(&token_key(token)).await {
Ok(Some(json)) => json,
Ok(None) => return, Err(e) => {
tracing::warn!(
"double-check reread failed, skip deleting expired Token-Session (token={}...): {}",
token.get(..8).unwrap_or(token),
e
);
return;
},
};
let Ok(ts) = serde_json::from_str::<TokenSession>(&json) else {
return; };
let now = Utc::now().timestamp();
let ttl = ts
.effective_timeout
.unwrap_or(self.timeout.min(i64::MAX as u64) as i64);
if ts.last_active_at + ttl < now {
self.trigger_expiry_listeners(&ts.login_id, token).await;
if let Err(e) = self.dao.delete(&token_key(token)).await {
tracing::warn!(
"failed to delete expired Token-Session (token={}...): {}",
token.get(..8).unwrap_or(token),
e
);
}
}
}
async fn delete_account_session_if_still_expired(&self, login_id: &str) {
let json = match self.dao.get(&account_key(login_id)).await {
Ok(Some(json)) => json,
Ok(None) => return,
Err(e) => {
tracing::warn!(
"double-check reread failed, skip deleting expired Account-Session (login_id={}): {}",
login_id,
e
);
return;
},
};
let Ok(as_) = serde_json::from_str::<AccountSession>(&json) else {
return;
};
let now = Utc::now().timestamp();
if as_.last_active_at + (self.active_timeout.min(i64::MAX as u64) as i64) < now {
self.trigger_expiry_listeners(login_id, "").await;
if let Err(e) = self.dao.delete(&account_key(login_id)).await {
tracing::warn!(
"failed to delete expired Account-Session (login_id={}): {}",
login_id,
e
);
}
}
}
pub async fn get_token_session(&self, token: &str) -> GarrisonResult<Option<TokenSession>> {
match self.dao.get(&token_key(token)).await? {
Some(json) => {
let ts: TokenSession = serde_json::from_str(&json).map_err(|e| {
GarrisonError::Session(format!("session-sim-token-deserialize::{}", e))
})?;
let now = Utc::now().timestamp();
let ttl = ts
.effective_timeout
.unwrap_or(self.timeout.min(i64::MAX as u64) as i64);
if ts.last_active_at + ttl < now {
self.delete_token_session_if_still_expired(token).await;
return Ok(None);
}
Ok(Some(ts))
},
None => Ok(None),
}
}
pub async fn get_token_session_with_ttl(
&self,
token: &str,
) -> GarrisonResult<Option<(TokenSession, Option<Duration>)>> {
let key = token_key(token);
match self.dao.get_with_ttl(&key).await? {
Some((json, ttl)) => {
let ts: TokenSession = serde_json::from_str(&json).map_err(|e| {
GarrisonError::Session(format!("session-sim-token-deserialize::{}", e))
})?;
let now = Utc::now().timestamp();
let effective_ttl = ts
.effective_timeout
.unwrap_or(self.timeout.min(i64::MAX as u64) as i64);
if ts.last_active_at + effective_ttl < now {
self.delete_token_session_if_still_expired(token).await;
return Ok(None);
}
Ok(Some((ts, ttl)))
},
None => Ok(None),
}
}
pub async fn get_account_session(
&self,
login_id: impl Into<String>,
) -> GarrisonResult<Option<AccountSession>> {
let login_id: String = login_id.into();
match self.dao.get(&account_key(&login_id)).await? {
Some(json) => {
let as_: AccountSession = serde_json::from_str(&json).map_err(|e| {
GarrisonError::Session(format!("session-sim-account-deserialize::{}", e))
})?;
let now = Utc::now().timestamp();
if as_.last_active_at + (self.active_timeout.min(i64::MAX as u64) as i64) < now {
self.delete_account_session_if_still_expired(&login_id)
.await;
return Ok(None);
}
Ok(Some(as_))
},
None => Ok(None),
}
}
pub fn add_login_token(&self, login_id: &str, token: &str) {
let mut entry = self
.login_token_map
.entry(login_id.to_string())
.or_default();
if !entry.contains(&token.to_string()) {
entry.push(token.to_string());
}
}
pub fn remove_login_token(&self, login_id: &str, token: &str) {
if let Some(mut entry) = self.login_token_map.get_mut(login_id) {
entry.retain(|t| t != token);
if entry.is_empty() {
drop(entry); self.login_token_map.remove(login_id);
}
}
}
pub fn get_token_by_login_id(&self, login_id: &str) -> Option<String> {
self.login_token_map
.get(login_id)
.and_then(|tokens| tokens.first().cloned())
}
pub fn get_tokens_by_login_id(&self, login_id: &str) -> Vec<String> {
self.login_token_map
.get(login_id)
.map(|tokens| tokens.clone())
.unwrap_or_default()
}
pub async fn cleanup_expired_tokens(&self) -> GarrisonResult<usize> {
let mut removed = 0usize;
let login_ids: Vec<String> = self
.login_token_map
.iter()
.map(|r| r.key().clone())
.collect();
for login_id in login_ids {
let tokens: Vec<String> = match self.login_token_map.get(&login_id) {
Some(t) => t.clone(),
None => continue, };
let mut expired: Vec<String> = Vec::new();
for token in &tokens {
match self.get_token_session(token).await {
Ok(None) => expired.push(token.clone()),
Ok(Some(_)) => {}, Err(e) => tracing::warn!(
"cleanup_expired_tokens: token={} DAO read failed, skipping this token: {}",
token,
e
),
}
}
if expired.is_empty() {
continue; }
removed += expired.len();
if let Some(mut entry) = self.login_token_map.get_mut(&login_id) {
entry.retain(|x| !expired.contains(x));
if entry.is_empty() {
drop(entry); self.login_token_map.remove(&login_id);
}
}
}
Ok(removed)
}
pub async fn vacuum_expired(&self) -> GarrisonResult<u64> {
self.dao.vacuum_expired().await
}
#[cfg(feature = "session-extra")]
pub async fn rebuild_login_token_map(&self) -> GarrisonResult<()> {
self.login_token_map.clear();
let keys = self.dao.keys("account:session:*").await?;
for key in keys {
let Some(login_id) = key.strip_prefix("account:session:") else {
tracing::warn!(
"rebuild_login_token_map: skipping key not matching account:session:{{login_id}} pattern: {}",
key
);
continue;
};
if let Some(json) = self.dao.get(&key).await? {
let session: AccountSession = match serde_json::from_str(&json) {
Ok(s) => s,
Err(e) => {
tracing::warn!(
key = %key,
error = %e,
"rebuild_login_token_map: skipping AccountSession that failed deserialization"
);
continue;
},
};
let tokens: Vec<String> = session.tokens.into_iter().map(|ti| ti.token).collect();
self.login_token_map.insert(login_id.to_string(), tokens);
}
}
Ok(())
}
#[cfg(feature = "session-extra")]
pub async fn add_login_token_persistent(
&self,
login_id: &str,
token: &str,
) -> GarrisonResult<()> {
let login_id: String = login_id.to_string();
self.with_login_lock(&login_id, async {
let mut account = self.get_account_session(&login_id).await?.ok_or_else(|| {
GarrisonError::Session(format!("session-account-not-found::{}", login_id))
})?;
let now = Utc::now().timestamp();
if !account.tokens.iter().any(|ti| ti.token == token) {
account.tokens.push(TokenInfo {
token: token.to_string(),
created_at: now,
last_active_at: now,
});
}
account.last_active_at = now;
let json = serde_json::to_string(&account).map_err(|e| {
GarrisonError::Session(format!("session-sim-account-serialize::{}", e))
})?;
self.dao.update(&account_key(&login_id), &json).await?;
self.add_login_token(&login_id, token);
Ok(())
})
.await
}
#[cfg(feature = "session-extra")]
pub async fn remove_login_token_persistent(
&self,
login_id: &str,
token: &str,
) -> GarrisonResult<()> {
let login_id: String = login_id.to_string();
self.with_login_lock(&login_id, async {
let mut account = self.get_account_session(&login_id).await?.ok_or_else(|| {
GarrisonError::Session(format!("session-account-not-found::{}", login_id))
})?;
account.tokens.retain(|ti| ti.token != token);
let json = serde_json::to_string(&account).map_err(|e| {
GarrisonError::Session(format!("session-sim-account-serialize::{}", e))
})?;
self.dao.update(&account_key(&login_id), &json).await?;
self.remove_login_token(&login_id, token);
Ok(())
})
.await
}
pub async fn set(&self, token: &str, key: &str, value: &str) -> GarrisonResult<()> {
self.with_token_session_lock(token, async {
let mut ts = self.get_token_session(token).await?.ok_or_else(|| {
GarrisonError::InvalidToken("session-token-not-found::".to_string())
})?;
ts.attrs.insert(key.to_string(), value.to_string());
ts.last_active_at = Utc::now().timestamp();
let json = serde_json::to_string(&ts).map_err(|e| {
GarrisonError::Session(format!("session-sim-token-serialize::{}", e))
})?;
self.dao.update(&token_key(token), &json).await?;
Ok(())
})
.await
}
pub async fn get(&self, token: &str, key: &str) -> GarrisonResult<Option<String>> {
match self.get_token_session(token).await? {
Some(ts) => Ok(ts.attrs.get(key).cloned()),
None => Ok(None),
}
}
pub async fn save_token_session(&self, token: &str, ts: &TokenSession) -> GarrisonResult<()> {
let json = serde_json::to_string(ts)
.map_err(|e| GarrisonError::Session(format!("session-sim-token-serialize::{}", e)))?;
self.dao.update(&token_key(token), &json).await?;
Ok(())
}
pub async fn append_amr_entry(
&self,
token: &str,
method: &str,
aal: u8,
completed_at: i64,
) -> GarrisonResult<()> {
let entry = crate::stp::mfa::AmrEntry::new(method, aal, completed_at)?;
self.with_token_session_lock(token, async {
let mut ts = self.get_token_session(token).await?.ok_or_else(|| {
GarrisonError::InvalidToken("session-token-not-found::".to_string())
})?;
if let Some(existing) = ts
.amr_ledger
.iter_mut()
.find(|e| e.method == entry.method && e.aal == entry.aal)
{
existing.completed_at = entry.completed_at;
} else {
ts.amr_ledger.push(entry);
}
if ts.auth_time.is_none() {
ts.auth_time = Some(
ts.amr_ledger
.first()
.map(|e| e.completed_at)
.unwrap_or_default(),
);
}
let json = serde_json::to_string(&ts).map_err(|e| {
GarrisonError::Session(format!("session-sim-token-serialize::{}", e))
})?;
self.dao.update(&token_key(token), &json).await?;
Ok(())
})
.await
}
pub async fn ensure_token_in_account_session(
&self,
login_id: &str,
token: &str,
) -> GarrisonResult<()> {
let login_id: String = login_id.to_string();
self.with_login_lock(&login_id, async {
let now = Utc::now().timestamp();
let mut account = match self.get_account_session(&login_id).await? {
Some(acc) => acc,
None => {
return Err(GarrisonError::InvalidParam(format!(
"session-account-not-found::{}",
login_id
)));
},
};
if let Some(ti) = account.tokens.iter_mut().find(|t| t.token == token) {
ti.last_active_at = now;
} else {
account.tokens.push(TokenInfo {
token: token.to_string(),
created_at: now,
last_active_at: now,
});
}
account.last_active_at = now;
let json = serde_json::to_string(&account).map_err(|e| {
GarrisonError::Session(format!("session-sim-account-serialize::{}", e))
})?;
self.dao
.set(&account_key(&login_id), &json, self.active_timeout)
.await?;
self.add_login_token(&login_id, token);
Ok(())
})
.await
}
pub async fn remove_token_from_account_session(
&self,
login_id: &str,
token: &str,
) -> GarrisonResult<()> {
let login_id: String = login_id.to_string();
self.with_login_lock(&login_id, async {
let mut account = match self.get_account_session(&login_id).await? {
Some(acc) => acc,
None => {
return Err(GarrisonError::InvalidParam(format!(
"session-account-not-found::{}",
login_id
)));
},
};
account.tokens.retain(|ti| ti.token != token);
let json = serde_json::to_string(&account).map_err(|e| {
GarrisonError::Session(format!("session-sim-account-serialize::{}", e))
})?;
self.dao.update(&account_key(&login_id), &json).await?;
self.remove_login_token(&login_id, token);
Ok(())
})
.await
}
pub async fn get_token_timeout(&self, token: &str) -> GarrisonResult<Option<Duration>> {
self.dao.get_timeout(&token_key(token)).await
}
pub async fn create_token_session_with_ttl(
&self,
token: &str,
ts: &TokenSession,
ttl_seconds: u64,
) -> GarrisonResult<()> {
let json = serde_json::to_string(ts)
.map_err(|e| GarrisonError::Session(format!("session-sim-token-serialize::{}", e)))?;
self.dao.set(&token_key(token), &json, ttl_seconds).await?;
Ok(())
}
pub async fn set_token_session_ttl(&self, token: &str, ttl_seconds: u64) -> GarrisonResult<()> {
self.dao.expire(&token_key(token), ttl_seconds).await
}
pub async fn link_sso_ticket(&self, token: &str, ticket: &str) -> GarrisonResult<()> {
self.set(token, "sso_ticket", ticket).await
}
pub async fn get_sso_ticket(&self, token: &str) -> GarrisonResult<Option<String>> {
self.get(token, "sso_ticket").await
}
pub async fn link_oauth2_token(&self, token: &str, access_token: &str) -> GarrisonResult<()> {
self.set(token, "oauth2_access_token", access_token).await
}
pub async fn get_oauth2_token(&self, token: &str) -> GarrisonResult<Option<String>> {
self.get(token, "oauth2_access_token").await
}
pub async fn link_temp_credential(&self, token: &str, temp_key: &str) -> GarrisonResult<()> {
self.set(token, "temp_credential_key", temp_key).await
}
pub async fn get_temp_credential(&self, token: &str) -> GarrisonResult<Option<String>> {
self.get(token, "temp_credential_key").await
}
pub async fn set_device(&self, token: &str, device: &str) -> GarrisonResult<()> {
self.with_token_session_lock(token, async {
let mut ts = self.get_token_session(token).await?.ok_or_else(|| {
GarrisonError::InvalidToken("session-token-not-found::".to_string())
})?;
ts.device = Some(device.to_string());
ts.last_active_at = Utc::now().timestamp();
let json = serde_json::to_string(&ts).map_err(|e| {
GarrisonError::Session(format!("session-sim-token-serialize::{}", e))
})?;
self.dao.update(&token_key(token), &json).await?;
Ok(())
})
.await
}
#[cfg(feature = "session-extra")]
pub async fn set_active_timeout(&self, token: &str, timeout_secs: i64) -> GarrisonResult<()> {
if timeout_secs == 0 {
return Err(GarrisonError::InvalidParam(
"session-timeout-secs-invalid".to_string(),
));
}
self.with_token_session_lock(token, async {
let mut ts = self.get_token_session(token).await?.ok_or_else(|| {
GarrisonError::InvalidToken(format!("session-token-not-found::{}", token))
})?;
ts.dynamic_active_timeout = Some(timeout_secs);
ts.last_active_at = Utc::now().timestamp();
let json = serde_json::to_string(&ts).map_err(|e| {
GarrisonError::Session(format!("session-sim-token-serialize::{}", e))
})?;
self.dao.update(&token_key(token), &json).await?;
Ok(())
})
.await
}
pub async fn is_valid(&self, token: &str) -> GarrisonResult<bool> {
Ok(self.is_valid_with_session(token).await?.is_some())
}
pub async fn is_valid_with_session(
&self,
token: &str,
) -> GarrisonResult<Option<crate::session::TokenSession>> {
let ts = match self.get_token_session(token).await? {
Some(ts) => ts,
None => return Ok(None),
};
#[cfg(feature = "session-extra")]
{
let effective_active_timeout = ts
.dynamic_active_timeout
.unwrap_or(self.active_timeout.min(i64::MAX as u64) as i64);
let now = Utc::now().timestamp();
if effective_active_timeout >= 0 && ts.last_active_at + effective_active_timeout < now {
return Ok(None);
}
}
if self.get_account_session(&ts.login_id).await?.is_none() {
return Ok(None);
}
if let Some(temp_key) = ts.attrs.get("temp_credential_key") {
if self.dao.get(temp_key).await?.is_none() {
return Ok(None);
}
}
Ok(Some(ts))
}
pub async fn touch(&self, token: &str) -> GarrisonResult<()> {
let ts = self.get_token_session(token).await?.ok_or_else(|| {
GarrisonError::InvalidToken(format!("session-token-not-found::{}", token))
})?;
let login_id = ts.login_id;
self.with_login_lock(&login_id, async {
self.with_token_session_lock(token, async {
let mut ts = self.get_token_session(token).await?.ok_or_else(|| {
GarrisonError::InvalidToken(format!("session-token-not-found::{}", token))
})?;
let now = Utc::now().timestamp();
ts.last_active_at = now;
let json = serde_json::to_string(&ts).map_err(|e| {
GarrisonError::Session(format!("session-sim-token-serialize::{}", e))
})?;
let ttl = match self.dao.get_with_ttl(&token_key(token)).await? {
Some((_, Some(remaining))) => remaining.as_secs(),
_ => ts.effective_timeout.unwrap_or(self.timeout as i64).max(0) as u64,
};
self.dao.set(&token_key(token), &json, ttl).await?;
if let Some(mut account) = self.get_account_session(&ts.login_id).await? {
account.last_active_at = now;
for ti in &mut account.tokens {
if ti.token == token {
ti.last_active_at = now;
}
}
let account_json = serde_json::to_string(&account).map_err(|e| {
GarrisonError::Session(format!("session-sim-account-serialize::{}", e))
})?;
self.dao
.set(
&account_key(&ts.login_id),
&account_json,
self.active_timeout,
)
.await?;
}
Ok(())
})
.await
})
.await
}
pub async fn renew(&self, token: &str) -> GarrisonResult<()> {
if self.get_token_session(token).await?.is_none() {
return Err(GarrisonError::InvalidToken(format!(
"session-token-not-found::{}",
token
)));
}
self.touch(token).await
}
pub async fn logout(&self, token: &str) -> GarrisonResult<()> {
#[cfg(feature = "session-extra")]
{
let is_anon = match self.is_anon(token).await {
Ok(v) => v,
Err(GarrisonError::InvalidParam(_)) => false,
Err(e) => return Err(e),
};
if is_anon {
return self.logout_anon(token).await;
}
}
let ts = self.get_token_session(token).await?;
match ts {
Some(ts) => {
let login_id = ts.login_id.clone();
self.with_login_lock(
&login_id,
async move { self.logout_inner(token, &ts).await },
)
.await
},
None => {
self.dao.delete(&token_key(token)).await
},
}
}
pub(crate) async fn logout_inner(&self, token: &str, ts: &TokenSession) -> GarrisonResult<()> {
self.dao.delete(&token_key(token)).await?;
if let Some(ticket) = ts.attrs.get("sso_ticket") {
let sso_key = format!("garrison:sso:ticket:{}", ticket);
if let Err(e) = self.dao.delete(&sso_key).await {
tracing::warn!(
"logout failed to delete SSO ticket (key={}): {}",
sso_key,
e
);
}
}
if let Some(mut account) = self.get_account_session(&ts.login_id).await? {
account.tokens.retain(|ti| ti.token != token);
let account_json = serde_json::to_string(&account).map_err(|e| {
GarrisonError::Session(format!("session-sim-account-serialize::{}", e))
})?;
self.dao
.update(&account_key(&ts.login_id), &account_json)
.await?;
}
self.remove_login_token(&ts.login_id, token);
Ok(())
}
pub async fn logout_by_login_id(&self, login_id: impl Into<String>) -> GarrisonResult<()> {
let login_id: String = login_id.into();
self.with_login_lock(&login_id, async {
self.logout_by_login_id_inner(&login_id).await
})
.await
}
pub(crate) async fn logout_by_login_id_inner(&self, login_id: &str) -> GarrisonResult<()> {
if let Some(account) = self.get_account_session(login_id).await? {
for ti in &account.tokens {
self.dao.delete(&token_key(&ti.token)).await?;
}
}
self.dao.delete(&account_key(login_id)).await?;
self.login_token_map.remove(login_id);
Ok(())
}
pub async fn kickout_by_device(
&self,
login_id: impl Into<String>,
device: &str,
) -> GarrisonResult<()> {
let login_id: String = login_id.into();
self.with_login_lock(&login_id, async {
let account = match self.get_account_session(&login_id).await? {
Some(a) => a,
None => return Ok(()), };
let mut kicked: Vec<(String, TokenSession)> = Vec::new();
for ti in &account.tokens {
if let Some(ts) = self.get_token_session(&ti.token).await? {
if ts.device.as_deref() == Some(device) {
kicked.push((ti.token.clone(), ts));
}
}
}
if kicked.is_empty() {
return Ok(()); }
for (token, ts) in &kicked {
self.logout_inner(token, ts).await?;
}
#[cfg(feature = "listener")]
if let Some(mgr) = &self.listener_manager {
let reason = format!("kicked by device: {}", device);
for (token, _) in &kicked {
mgr.broadcast(&crate::listener::GarrisonEvent::Kickout {
login_id: login_id.clone(),
token: crate::listener::mask_token_for_event(token),
reason: reason.clone(),
request_context: None,
})
.await;
}
}
Ok(())
})
.await
}
}
#[cfg(feature = "session-extra")]
impl GarrisonSession {
pub async fn get_anon_token_session(&self, token: &str) -> GarrisonResult<TokenSession> {
anon::get_anon_token_session(self, token).await
}
pub async fn is_anon(&self, token: &str) -> GarrisonResult<bool> {
anon::is_anon(self, token).await
}
pub async fn logout_anon(&self, token: &str) -> GarrisonResult<()> {
anon::logout_anon(self, token).await
}
}
#[cfg(feature = "session-extra")]
impl GarrisonSession {
pub async fn search_token_value(
&self,
keyword: &str,
start: usize,
size: usize,
sort_type: SearchSortType,
) -> GarrisonResult<(Vec<String>, bool)> {
search::search_token_value(self, keyword, start, size, sort_type).await
}
pub async fn search_session_id(
&self,
keyword: &str,
start: usize,
size: usize,
sort_type: SearchSortType,
) -> GarrisonResult<(Vec<String>, bool)> {
search::search_session_id(self, keyword, start, size, sort_type).await
}
pub async fn search_token_session_id(
&self,
keyword: &str,
start: usize,
size: usize,
sort_type: SearchSortType,
) -> GarrisonResult<(Vec<String>, bool)> {
search::search_token_session_id(self, keyword, start, size, sort_type).await
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::tests::{MockDao, VacuumCountingDao};
use chrono::Utc;
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
fn make_session(timeout: u64, active_timeout: u64) -> (Arc<MockDao>, GarrisonSession) {
let dao = Arc::new(MockDao::new());
let session = GarrisonSession::new(dao.clone(), timeout, active_timeout, 0);
(dao, session)
}
#[tokio::test]
async fn vacuum_expired_forwards_to_dao() {
let dao = Arc::new(VacuumCountingDao::new(7));
let session = GarrisonSession::new(dao.clone(), 3600, 86400, 0);
let removed = session.vacuum_expired().await.unwrap();
assert_eq!(removed, 7, "转发应返回 DAO 的 vacuum_expired 删除计数");
assert_eq!(
dao.calls(),
1,
"session 转发应恰触发 1 次 DAO vacuum_expired"
);
}
#[tokio::test]
async fn remember_me_token_uses_effective_timeout_as_authoritative() {
let dao = Arc::new(MockDao::new());
let session = GarrisonSession::new(dao.clone(), 3600, 86400, 7_776_000);
let login_id = "user-remember-me";
let token = "rm-token-001";
let params = crate::stp::LoginParams {
remember_me: true,
..Default::default()
};
session
.create_token_session(login_id, token, ¶ms)
.await
.unwrap();
let ts = session.get_token_session(token).await.unwrap().unwrap();
assert_eq!(
ts.effective_timeout,
Some(7_776_000),
"remember-me 登录应将 effective_timeout 写入会话记录"
);
ts_set_last_active(&session, token, Utc::now().timestamp() - 100).await;
ts_set_last_active(&session, token, Utc::now().timestamp() - 7_776_001).await;
let expired = session.get_token_session(token).await.unwrap();
assert!(
expired.is_none(),
"超过 effective_timeout 的 remember-me token 应被判定过期"
);
let session2 = GarrisonSession::new(Arc::new(MockDao::new()), 3600, 86400, 7_776_000);
let params2 = crate::stp::LoginParams {
remember_me: false,
..Default::default()
};
session2
.create_token_session(login_id, "normal-token", ¶ms2)
.await
.unwrap();
let ts2 = session2
.get_token_session("normal-token")
.await
.unwrap()
.unwrap();
assert_eq!(
ts2.effective_timeout, None,
"非 remember-me 登录 effective_timeout 应为 None(使用全局 timeout)"
);
let _ = dao;
}
#[tokio::test]
async fn remember_me_session_survives_base_timeout_but_expires_at_remember_me_timeout() {
let session = GarrisonSession::new(Arc::new(MockDao::new()), 3600, 86400, 7_776_000);
let login_id = "user-rm-integration";
let token = "rm-itoken";
let params = crate::stp::LoginParams {
remember_me: true,
..Default::default()
};
session
.create_token_session(login_id, token, ¶ms)
.await
.unwrap();
ts_set_last_active(&session, token, Utc::now().timestamp() - 7200).await;
let live = session.get_token_session(token).await.unwrap();
assert!(
live.is_some(),
"空闲超过基础 timeout 但仍在 remember_me_timeout 内,会话应仍然有效"
);
assert_eq!(live.unwrap().effective_timeout, Some(7_776_000));
}
async fn ts_set_last_active(session: &GarrisonSession, token: &str, ts: i64) {
let mut s = session.get_token_session(token).await.unwrap().unwrap();
s.last_active_at = ts;
let json = serde_json::to_string(&s).unwrap();
session
.dao
.set(&token_key(token), &json, 7_776_000)
.await
.unwrap();
}
#[test]
fn update_last_active_at_sets_specified_timestamp() {
let (_dao, session) = make_session(3600, 86400);
let specified_ts: i64 = 1_700_000_000_000;
session.update_last_active_at("user_injected", specified_ts);
let stored = session.get_last_active("user_injected");
assert_eq!(
stored,
Some(specified_ts),
"update_last_active_at 应写入指定时间戳而非当前时间"
);
}
#[test]
fn add_login_token_deduplicates_existing_token() {
let (_dao, session) = make_session(3600, 86400);
session.add_login_token("user1", "token1");
session.add_login_token("user1", "token1"); session.add_login_token("user1", "token2");
let tokens = session.get_tokens_by_login_id("user1");
assert_eq!(
tokens,
vec!["token1".to_string(), "token2".to_string()],
"重复 token 不应重复计入列表"
);
}
#[tokio::test]
async fn ensure_token_in_account_session_updates_last_active_for_existing_token() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let original = session.get_account_session("1001").await.unwrap().unwrap();
let original_active = original.last_active_at;
tokio::time::sleep(Duration::from_secs(2)).await;
session
.ensure_token_in_account_session("1001", "T1")
.await
.unwrap();
let after = session.get_account_session("1001").await.unwrap().unwrap();
assert_eq!(
after.tokens.len(),
1,
"token 已存在时不应重复添加到 tokens 列表"
);
assert!(
after.last_active_at > original_active,
"ensure 已存在的 token 应更新 last_active_at(原={}, 新={})",
original_active,
after.last_active_at
);
let ti = after.tokens.iter().find(|t| t.token == "T1").unwrap();
assert!(
ti.last_active_at > original_active,
"TokenInfo.last_active_at 也应被更新"
);
}
#[tokio::test]
async fn ensure_token_in_account_session_returns_error_for_nonexistent_login_id() {
let (_dao, session) = make_session(3600, 86400);
let result = session
.ensure_token_in_account_session("nonexistent-2002", "T1")
.await;
assert!(
result.is_err(),
"Account-Session 不存在时应返回 Err,避免静默创建导致提权。实际: {:?}",
result
);
let after = session
.get_account_session("nonexistent-2002")
.await
.unwrap();
assert!(
after.is_none(),
"应未创建 Account-Session(避免数据不一致),实际: {:?}",
after
);
}
#[tokio::test]
async fn save_token_session_persists_modified_session() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let mut ts = session.get_token_session("T1").await.unwrap().unwrap();
ts.attrs
.insert("custom_key".to_string(), "custom_value".to_string());
session.save_token_session("T1", &ts).await.unwrap();
let reloaded = session.get_token_session("T1").await.unwrap().unwrap();
assert_eq!(
reloaded.attrs.get("custom_key").map(|s| s.as_str()),
Some("custom_value"),
"save_token_session 后自定义属性应持久化"
);
}
#[tokio::test]
async fn ttl_methods_roundtrip() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let new_ts = TokenSession {
token: "T2".to_string(),
login_id: "1001".to_string(),
created_at: Utc::now().timestamp(),
last_active_at: Utc::now().timestamp(),
attrs: HashMap::new(),
device: None,
ip: None,
user_agent: None,
safe_services: HashMap::new(),
#[cfg(feature = "session-extra")]
dynamic_active_timeout: None,
#[cfg(feature = "session-extra")]
is_anon: false,
effective_timeout: None,
amr_ledger: Vec::new(),
auth_time: None,
};
session
.create_token_session_with_ttl("T2", &new_ts, 600)
.await
.unwrap();
let ttl = session.get_token_timeout("T2").await.unwrap();
assert!(
ttl.is_some(),
"create_token_session_with_ttl 设置了 TTL=600,应返回 Some"
);
let ttl_secs = ttl.unwrap().as_secs();
assert!(
(590..=600).contains(&ttl_secs),
"TTL 应接近 600 秒,实际: {}",
ttl_secs
);
session.set_token_session_ttl("T2", 1200).await.unwrap();
let ttl_after = session
.get_token_timeout("T2")
.await
.unwrap()
.expect("set_token_session_ttl 后应仍返回 Some");
let ttl_after_secs = ttl_after.as_secs();
assert!(
(1190..=1200).contains(&ttl_after_secs),
"set_token_session_ttl 后 TTL 应接近 1200 秒,实际: {}",
ttl_after_secs
);
}
#[cfg(feature = "session-extra")]
#[test]
fn with_anon_session_timeout_sets_field() {
use crate::config::DEFAULT_ANON_SESSION_TIMEOUT_SECS;
use crate::dao::GarrisonDao;
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let default_session = GarrisonSession::new(dao.clone(), 3600, 86400, 0);
assert_eq!(
default_session.anon_session_timeout, DEFAULT_ANON_SESSION_TIMEOUT_SECS,
"new 默认应使用 DEFAULT_ANON_SESSION_TIMEOUT_SECS"
);
let session = GarrisonSession::new(dao, 3600, 86400, 0).with_anon_session_timeout(99);
assert_eq!(
session.anon_session_timeout, 99,
"with_anon_session_timeout 应设置字段为指定值"
);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn with_token_session_lock_serializes_same_token() {
use std::sync::atomic::{AtomicUsize, Ordering};
let (_dao, session) = make_session(3600, 86400);
let session = Arc::new(session);
let counter = Arc::new(AtomicUsize::new(0));
let max_concurrent = Arc::new(AtomicUsize::new(0));
let counter_a = counter.clone();
let max_a = max_concurrent.clone();
let session_a = session.clone();
let h1 = tokio::spawn(async move {
session_a
.with_token_session_lock("T1", async {
let cur = counter_a.fetch_add(1, Ordering::SeqCst) + 1;
max_a.fetch_max(cur, Ordering::SeqCst);
tokio::time::sleep(Duration::from_millis(50)).await;
counter_a.fetch_sub(1, Ordering::SeqCst);
})
.await
});
let counter_b = counter.clone();
let max_b = max_concurrent.clone();
let session_b = session.clone();
let h2 = tokio::spawn(async move {
session_b
.with_token_session_lock("T1", async {
let cur = counter_b.fetch_add(1, Ordering::SeqCst) + 1;
max_b.fetch_max(cur, Ordering::SeqCst);
tokio::time::sleep(Duration::from_millis(50)).await;
counter_b.fetch_sub(1, Ordering::SeqCst);
})
.await
});
h1.await.unwrap();
h2.await.unwrap();
assert_eq!(
max_concurrent.load(Ordering::SeqCst),
1,
"with_token_session_lock 应串行化同一 token 的并发操作"
);
}
#[test]
fn check_hover_timeout_disabled_when_secs_le_zero() {
let (_dao, session) = make_session(3600, 86400);
assert!(
session.check_hover_timeout("user1", 0),
"hover_timeout_secs=0 应返回 true(不启用)"
);
assert!(
session.check_hover_timeout("user1", -1),
"hover_timeout_secs=-1 应返回 true(不启用)"
);
}
#[test]
fn check_hover_timeout_returns_true_when_no_active_record() {
let (_dao, session) = make_session(3600, 86400);
assert!(
session.check_hover_timeout("never_seen_user", 300),
"无活跃记录时应返回 true(不踢出首次 check_login)"
);
}
#[test]
fn check_hover_timeout_returns_true_when_within_timeout() {
let (_dao, session) = make_session(3600, 86400);
let now = chrono::Utc::now().timestamp_millis();
session.update_last_active_at("active_user", now);
assert!(
session.check_hover_timeout("active_user", 300),
"刚活跃的用户在悬停超时内应返回 true"
);
}
#[test]
fn check_hover_timeout_returns_false_when_hover_expired() {
let (_dao, session) = make_session(3600, 86400);
let old_time = chrono::Utc::now().timestamp_millis() - 600_000; session.update_last_active_at("idle_user", old_time);
assert!(
!session.check_hover_timeout("idle_user", 300),
"悬停超时后应返回 false(应踢出)"
);
}
#[test]
fn update_last_active_and_get_last_active_roundtrip() {
let (_dao, session) = make_session(3600, 86400);
let before = chrono::Utc::now().timestamp_millis();
session.update_last_active("roundtrip_user");
let after = chrono::Utc::now().timestamp_millis();
let stored = session.get_last_active("roundtrip_user");
assert!(
stored.is_some(),
"update_last_active 后应能 get_last_active"
);
let ts = stored.unwrap();
assert!(
ts >= before && ts <= after,
"存储的时间戳应在调用前后的范围内"
);
assert!(
session.get_last_active("nonexistent_user").is_none(),
"不存在的 login_id 应返回 None"
);
}
#[test]
fn remove_login_token_removes_entry_when_empty() {
let (_dao, session) = make_session(3600, 86400);
session.add_login_token("user1", "token1");
assert_eq!(
session.get_tokens_by_login_id("user1"),
vec!["token1".to_string()]
);
session.remove_login_token("user1", "token1");
assert!(
session.get_tokens_by_login_id("user1").is_empty(),
"移除最后一个 token 后 entry 应被删除"
);
assert!(
session.get_token_by_login_id("user1").is_none(),
"移除最后一个 token 后 get_token_by_login_id 应返回 None"
);
}
#[test]
fn remove_login_token_preserves_other_tokens() {
let (_dao, session) = make_session(3600, 86400);
session.add_login_token("user1", "token1");
session.add_login_token("user1", "token2");
session.add_login_token("user1", "token3");
session.remove_login_token("user1", "token2");
let tokens = session.get_tokens_by_login_id("user1");
assert_eq!(
tokens,
vec!["token1".to_string(), "token3".to_string()],
"移除 token2 后应保留 token1 和 token3"
);
}
#[test]
fn get_token_by_login_id_returns_first_or_none() {
let (_dao, session) = make_session(3600, 86400);
session.add_login_token("user1", "first_token");
session.add_login_token("user1", "second_token");
assert_eq!(
session.get_token_by_login_id("user1"),
Some("first_token".to_string()),
"应返回第一个 token"
);
assert!(
session.get_token_by_login_id("nonexistent").is_none(),
"不存在的 login_id 应返回 None"
);
}
#[test]
fn get_tokens_by_login_id_returns_empty_for_nonexistent() {
let (_dao, session) = make_session(3600, 86400);
assert!(
session
.get_tokens_by_login_id("nonexistent_user")
.is_empty(),
"不存在的 login_id 应返回空 Vec"
);
}
#[tokio::test]
async fn set_attr_on_nonexistent_token_returns_invalid_token() {
let (_dao, session) = make_session(3600, 86400);
let result = session.set("nonexistent_token", "key", "value").await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"set 不存在的 token 应返回 InvalidToken 错误"
);
}
#[tokio::test]
async fn set_and_get_custom_attr_roundtrip() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session
.set("T1", "custom_key", "custom_value")
.await
.unwrap();
let val = session.get("T1", "custom_key").await.unwrap();
assert_eq!(val.as_deref(), Some("custom_value"), "应读取已设置的属性");
let missing = session.get("T1", "missing_key").await.unwrap();
assert!(missing.is_none(), "不存在的属性应返回 None");
let missing_token = session.get("no_token", "key").await.unwrap();
assert!(missing_token.is_none(), "不存在的 token 应返回 None");
}
#[tokio::test]
async fn set_device_on_nonexistent_token_returns_invalid_token() {
let (_dao, session) = make_session(3600, 86400);
let result = session.set_device("nonexistent_token", "web-chrome").await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"set_device 不存在的 token 应返回 InvalidToken 错误"
);
}
#[tokio::test]
async fn create_token_session_writes_device_ip_user_agent_from_login_params() {
let (_dao, session) = make_session(3600, 86400);
let params = crate::stp::LoginParams {
device: Some("mobile-ios".to_string()),
ip: Some("192.168.1.100".to_string()),
user_agent: Some("Mozilla/5.0 (iPhone)".to_string()),
remember_me: false,
require_mfa: false,
};
session
.create_token_session("user1", "T1", ¶ms)
.await
.expect("create_token_session 应成功");
let ts = session
.get_token_session("T1")
.await
.expect("get_token_session 应成功")
.expect("Token-Session 应存在");
assert_eq!(ts.device.as_deref(), Some("mobile-ios"), "device 应被写入");
assert_eq!(ts.ip.as_deref(), Some("192.168.1.100"), "ip 应被写入");
assert_eq!(
ts.user_agent.as_deref(),
Some("Mozilla/5.0 (iPhone)"),
"user_agent 应被写入"
);
}
#[tokio::test]
async fn create_token_session_with_none_params_leaves_fields_none() {
let (_dao, session) = make_session(3600, 86400);
let params = crate::stp::LoginParams::default();
session
.create_token_session("user1", "T1", ¶ms)
.await
.expect("create_token_session 应成功");
let ts = session
.get_token_session("T1")
.await
.expect("get_token_session 应成功")
.expect("Token-Session 应存在");
assert!(ts.device.is_none(), "device 应为 None");
assert!(ts.ip.is_none(), "ip 应为 None");
assert!(ts.user_agent.is_none(), "user_agent 应为 None");
}
#[tokio::test]
async fn link_and_get_sso_ticket_roundtrip() {
let (_dao, session) = make_session(3600, 86400);
session.create("user1", "T1").await.unwrap();
session
.link_sso_ticket("T1", "ticket-abc-123")
.await
.expect("link_sso_ticket 应成功");
let ticket = session
.get_sso_ticket("T1")
.await
.expect("get_sso_ticket 应成功");
assert_eq!(
ticket.as_deref(),
Some("ticket-abc-123"),
"应读取已关联的 SSO ticket"
);
}
#[tokio::test]
async fn link_and_get_oauth2_token_roundtrip() {
let (_dao, session) = make_session(3600, 86400);
session.create("user1", "T1").await.unwrap();
session
.link_oauth2_token("T1", "oauth2-access-token-xyz")
.await
.expect("link_oauth2_token 应成功");
let token = session
.get_oauth2_token("T1")
.await
.expect("get_oauth2_token 应成功");
assert_eq!(
token.as_deref(),
Some("oauth2-access-token-xyz"),
"应读取已关联的 OAuth2 access_token"
);
}
#[tokio::test]
async fn link_and_get_temp_credential_roundtrip() {
let (_dao, session) = make_session(3600, 86400);
session.create("user1", "T1").await.unwrap();
let temp_key = "temp:cred:user1:20260714";
session
.link_temp_credential("T1", temp_key)
.await
.expect("link_temp_credential 应成功");
let stored = session
.get_temp_credential("T1")
.await
.expect("get_temp_credential 应成功");
assert_eq!(
stored.as_deref(),
Some(temp_key),
"应读取已关联的临时凭证 key"
);
}
#[tokio::test]
async fn renew_nonexistent_token_returns_invalid_token() {
let (_dao, session) = make_session(3600, 86400);
let result = session.renew("nonexistent_token").await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"renew 不存在的 token 应返回 InvalidToken 错误"
);
}
#[tokio::test]
async fn logout_nonexistent_token_is_idempotent() {
let (_dao, session) = make_session(3600, 86400);
let result = session.logout("nonexistent_token").await;
assert!(result.is_ok(), "logout 不存在的 token 应幂等返回 Ok(())");
}
#[cfg(feature = "protocol-apikey")]
#[test]
fn dao_accessor_returns_dao_reference() {
use crate::dao::GarrisonDao;
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let session = GarrisonSession::new(dao.clone(), 3600, 86400, 0);
let returned = session.dao();
let returned_ptr = Arc::as_ptr(returned);
let original_ptr = Arc::as_ptr(&dao);
assert!(
std::ptr::eq(returned_ptr, original_ptr),
"dao() 应返回内部 DAO 的引用"
);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn set_concurrent_no_lost_update() {
let (_dao, session) = make_session(3600, 86400);
let session = Arc::new(session);
session.create("user1", "T1").await.unwrap();
let mut handles = Vec::new();
for i in 0..10 {
let s = session.clone();
handles.push(tokio::spawn(async move {
s.set("T1", &format!("key{}", i), &format!("val{}", i))
.await
.unwrap();
}));
}
for h in handles {
h.await.unwrap();
}
for i in 0..10 {
let val = session.get("T1", &format!("key{}", i)).await.unwrap();
assert_eq!(
val,
Some(format!("val{}", i)),
"key{} 应存在(无 lost update),实际: {:?}",
i,
val
);
}
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn set_device_concurrent_with_set_no_lost_update() {
let (_dao, session) = make_session(3600, 86400);
let session = Arc::new(session);
session.create("user1", "T1").await.unwrap();
let s1 = session.clone();
let s2 = session.clone();
let h1 = tokio::spawn(async move {
s1.set_device("T1", "device-A").await.unwrap();
});
let h2 = tokio::spawn(async move {
s2.set("T1", "attr1", "val1").await.unwrap();
});
h1.await.unwrap();
h2.await.unwrap();
let ts = session.get_token_session("T1").await.unwrap().unwrap();
assert_eq!(ts.device, Some("device-A".to_string()));
assert_eq!(ts.attrs.get("attr1"), Some(&"val1".to_string()));
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn touch_concurrent_no_corruption() {
let (_dao, session) = make_session(3600, 86400);
let session = Arc::new(session);
session.create("user1", "T1").await.unwrap();
let mut handles = Vec::new();
for _ in 0..10 {
let s = session.clone();
handles.push(tokio::spawn(async move {
s.touch("T1").await.unwrap();
}));
}
for h in handles {
h.await.unwrap();
}
let ts = session.get_token_session("T1").await.unwrap();
assert!(ts.is_some(), "touch 并发后 session 应仍然存在");
}
#[tokio::test]
async fn with_token_session_lock_cleans_entry_after_completion() {
let (_dao, session) = make_session(3600, 86400);
assert!(
session.token_session_locks.is_empty(),
"调用前 token_session_locks 应为空"
);
let _ = session
.with_token_session_lock("test-token-cleanup", async { 42 })
.await;
assert!(
session.token_session_locks.is_empty(),
"调用后 token_session_locks 应清理为空(无等待者)"
);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn with_token_session_lock_cleans_all_entries_after_concurrent_calls() {
let (_dao, session) = make_session(3600, 86400);
let session = Arc::new(session);
assert!(
session.token_session_locks.is_empty(),
"并发调用前 token_session_locks 应为空"
);
let mut handles = Vec::new();
for i in 0..10 {
let s = session.clone();
handles.push(tokio::spawn(async move {
let token = format!("concurrent-token-{}", i);
s.with_token_session_lock(&token, async { i }).await
}));
}
for h in handles {
h.await.unwrap();
}
assert!(
session.token_session_locks.is_empty(),
"并发调用全部完成后 token_session_locks 应清理为空,实际残留 {} 个 entry",
session.token_session_locks.len()
);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn with_token_session_lock_keeps_entry_while_contended() {
let (_dao, session) = make_session(3600, 86400);
let session = Arc::new(session);
let barrier = Arc::new(tokio::sync::Barrier::new(2));
let b1 = barrier.clone();
let s1 = session.clone();
let h1 = tokio::spawn(async move {
s1.with_token_session_lock("contended-token", async move {
b1.wait().await;
tokio::time::sleep(Duration::from_millis(50)).await;
})
.await
});
let b2 = barrier.clone();
let s2 = session.clone();
let h2 = tokio::spawn(async move {
b2.wait().await;
s2.with_token_session_lock("contended-token", async { 42 })
.await
});
h1.await.unwrap();
h2.await.unwrap();
assert!(
session.token_session_locks.is_empty(),
"两个 task 都完成后 token_session_locks 应清理为空"
);
}
#[tokio::test]
async fn update_last_active_and_get_roundtrip_coverage() {
let (_dao, session) = make_session(3600, 86400);
assert!(
session.get_last_active("user1").is_none(),
"未更新前应返回 None"
);
session.update_last_active("user1");
let ts = session.get_last_active("user1");
assert!(ts.is_some(), "update_last_active 后应可读取");
assert!(ts.unwrap() > 0, "时间戳应为正数");
}
#[tokio::test]
async fn update_last_active_at_writes_exact_timestamp() {
let (_dao, session) = make_session(3600, 86400);
session.update_last_active_at("user2", 1700000000000);
assert_eq!(session.get_last_active("user2"), Some(1700000000000));
}
#[tokio::test]
async fn check_hover_timeout_disabled_returns_true() {
let (_dao, session) = make_session(3600, 86400);
assert!(
session.check_hover_timeout("user1", 0),
"hover_timeout=0 应返回 true"
);
assert!(
session.check_hover_timeout("user1", -1),
"hover_timeout=-1 应返回 true"
);
}
#[tokio::test]
async fn check_hover_timeout_no_record_returns_true() {
let (_dao, session) = make_session(3600, 86400);
assert!(
session.check_hover_timeout("new_user", 60),
"无记录应返回 true"
);
}
#[tokio::test]
async fn check_hover_timeout_recent_activity_returns_true() {
let (_dao, session) = make_session(3600, 86400);
session.update_last_active_at("user1", chrono::Utc::now().timestamp_millis());
assert!(
session.check_hover_timeout("user1", 60),
"最近活跃应返回 true"
);
}
#[tokio::test]
async fn check_hover_timeout_expired_returns_false() {
let (_dao, session) = make_session(3600, 86400);
session.update_last_active_at("user1", chrono::Utc::now().timestamp_millis() - 120_000);
assert!(
!session.check_hover_timeout("user1", 60),
"超过 60s 悬停超时后应返回 false"
);
}
#[tokio::test]
async fn add_expiry_listener_appends_to_list() {
use crate::session::SessionExpiryListener;
use async_trait::async_trait;
struct NoopListener;
#[async_trait]
impl SessionExpiryListener for NoopListener {
async fn on_session_expired(
&self,
_login_id: &str,
_token: &str,
) -> GarrisonResult<()> {
Ok(())
}
}
let (_dao, mut session) = make_session(3600, 86400);
assert!(session.expiry_listeners.is_empty());
session.add_expiry_listener(Arc::new(NoopListener));
assert_eq!(session.expiry_listeners.len(), 1);
session.add_expiry_listener(Arc::new(NoopListener));
assert_eq!(session.expiry_listeners.len(), 2);
}
enum GetAction {
Fail,
DeleteKey,
Rewrite(&'static str),
}
struct ScriptedDao {
inner: crate::dao::InMemoryDao,
on_get: parking_lot::Mutex<Vec<(String, u64, GetAction)>>,
fail_delete_keys: parking_lot::Mutex<Vec<String>>,
}
impl ScriptedDao {
fn new() -> Arc<Self> {
Arc::new(Self {
inner: crate::dao::InMemoryDao::new(),
on_get: parking_lot::Mutex::new(Vec::new()),
fail_delete_keys: parking_lot::Mutex::new(Vec::new()),
})
}
fn on_get_nth(&self, key: String, n: u64, action: GetAction) {
assert!(n >= 1);
self.on_get.lock().push((key, n, action));
}
fn fail_delete_on(&self, key: String) {
self.fail_delete_keys.lock().push(key);
}
fn take_action(&self, key: &str) -> Option<GetAction> {
let mut script = self.on_get.lock();
let idx = script.iter().position(|(k, _, _)| k == key)?;
let entry = &mut script[idx];
if entry.1 > 1 {
entry.1 -= 1;
return None;
}
Some(script.remove(idx).2)
}
}
#[async_trait]
impl crate::dao::GarrisonDao for ScriptedDao {
async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
match self.take_action(key) {
Some(GetAction::Fail) => {
return Err(GarrisonError::Dao("scripted get error".to_string()));
},
Some(GetAction::DeleteKey) => {
self.inner.delete(key).await?;
return Ok(None);
},
Some(GetAction::Rewrite(v)) => {
self.inner.update(key, v).await?;
},
None => {},
}
self.inner.get(key).await
}
async fn set(&self, key: &str, value: &str, ttl_seconds: u64) -> GarrisonResult<()> {
self.inner.set(key, value, ttl_seconds).await
}
async fn update(&self, key: &str, value: &str) -> GarrisonResult<()> {
self.inner.update(key, value).await
}
async fn expire(&self, key: &str, seconds: u64) -> GarrisonResult<()> {
self.inner.expire(key, seconds).await
}
async fn delete(&self, key: &str) -> GarrisonResult<()> {
if self.fail_delete_keys.lock().iter().any(|k| k == key) {
return Err(GarrisonError::Dao("scripted delete error".to_string()));
}
self.inner.delete(key).await
}
async fn set_if_absent(
&self,
key: &str,
value: &str,
ttl_seconds: u64,
) -> GarrisonResult<bool> {
self.inner.set_if_absent(key, value, ttl_seconds).await
}
async fn rename(&self, old_key: &str, new_key: &str) -> GarrisonResult<()> {
self.inner.rename(old_key, new_key).await
}
async fn get_and_delete(&self, key: &str) -> GarrisonResult<Option<String>> {
self.inner.get_and_delete(key).await
}
async fn incr(&self, key: &str, ttl_seconds: u64) -> GarrisonResult<u64> {
self.inner.incr(key, ttl_seconds).await
}
async fn decr(&self, key: &str) -> GarrisonResult<u64> {
self.inner.decr(key).await
}
async fn compare_and_swap(
&self,
key: &str,
expected: Option<&str>,
new_value: &str,
ttl_seconds: u64,
) -> GarrisonResult<bool> {
self.inner
.compare_and_swap(key, expected, new_value, ttl_seconds)
.await
}
}
async fn seed_expired_token_session(dao: &Arc<ScriptedDao>, token: &str) -> GarrisonSession {
let session = GarrisonSession::new(dao.clone(), 3600, 86400, 0);
session
.create_token_session("u-toctou", token, &crate::stp::LoginParams::default())
.await
.unwrap();
ts_set_last_active(&session, token, Utc::now().timestamp() - 7_200).await;
session
}
async fn seed_expired_account_session(
dao: &Arc<ScriptedDao>,
login_id: &str,
) -> GarrisonSession {
let session = GarrisonSession::new(dao.clone(), 3600, 3600, 0);
session
.create_token_session(login_id, "acct-tok-1", &crate::stp::LoginParams::default())
.await
.unwrap();
let mut acct = session
.get_account_session(login_id)
.await
.unwrap()
.unwrap();
acct.last_active_at = Utc::now().timestamp() - 7_200;
let json = serde_json::to_string(&acct).unwrap();
session
.dao
.set(&account_key(login_id), &json, 7200)
.await
.unwrap();
session
}
#[tokio::test]
async fn token_guard_reread_error_keeps_record() {
let dao = ScriptedDao::new();
let session = seed_expired_token_session(&dao, "guard-err-tok").await;
dao.on_get_nth(token_key("guard-err-tok"), 2, GetAction::Fail);
let live = session.get_token_session("guard-err-tok").await.unwrap();
assert!(live.is_none(), "过期会话对外仍应不可见");
let stored = dao.inner.get(&token_key("guard-err-tok")).await.unwrap();
assert!(
stored.is_some(),
"守卫重读失败时不得误删记录(TOCTOU 保守侧)"
);
}
#[tokio::test]
async fn token_guard_reread_missing_is_noop() {
let dao = ScriptedDao::new();
let session = seed_expired_token_session(&dao, "guard-gone-tok").await;
dao.on_get_nth(token_key("guard-gone-tok"), 2, GetAction::DeleteKey);
let live = session.get_token_session("guard-gone-tok").await.unwrap();
assert!(live.is_none());
let stored = dao.inner.get(&token_key("guard-gone-tok")).await.unwrap();
assert!(stored.is_none(), "并发已删的记录应保持已删");
}
#[tokio::test]
async fn token_guard_reread_corrupt_keeps_record() {
let dao = ScriptedDao::new();
let session = seed_expired_token_session(&dao, "guard-corrupt-tok").await;
dao.on_get_nth(
token_key("guard-corrupt-tok"),
2,
GetAction::Rewrite("{{{corrupt"),
);
let live = session
.get_token_session("guard-corrupt-tok")
.await
.unwrap();
assert!(live.is_none());
let stored = dao
.inner
.get(&token_key("guard-corrupt-tok"))
.await
.unwrap();
assert!(stored.is_some(), "损坏记录不由守卫处理(保守侧,不删)");
}
#[tokio::test]
async fn token_guard_delete_error_keeps_record() {
let dao = ScriptedDao::new();
dao.fail_delete_on(token_key("guard-del-err-tok"));
let session = seed_expired_token_session(&dao, "guard-del-err-tok").await;
let live = session
.get_token_session("guard-del-err-tok")
.await
.unwrap();
assert!(live.is_none());
let stored = dao
.inner
.get(&token_key("guard-del-err-tok"))
.await
.unwrap();
assert!(stored.is_some(), "删除失败时记录保留,等待下次清理");
}
#[tokio::test]
async fn account_guard_reread_error_keeps_record() {
let dao = ScriptedDao::new();
let session = seed_expired_account_session(&dao, "acct-guard-err").await;
dao.on_get_nth(account_key("acct-guard-err"), 2, GetAction::Fail);
let live = session.get_account_session("acct-guard-err").await.unwrap();
assert!(live.is_none(), "过期账号会话对外不可见");
let stored = dao.inner.get(&account_key("acct-guard-err")).await.unwrap();
assert!(stored.is_some(), "守卫重读失败时不得误删 Account-Session");
}
#[tokio::test]
async fn account_guard_reread_missing_is_noop() {
let dao = ScriptedDao::new();
let session = seed_expired_account_session(&dao, "acct-guard-gone").await;
dao.on_get_nth(account_key("acct-guard-gone"), 2, GetAction::DeleteKey);
let live = session
.get_account_session("acct-guard-gone")
.await
.unwrap();
assert!(live.is_none());
let stored = dao
.inner
.get(&account_key("acct-guard-gone"))
.await
.unwrap();
assert!(stored.is_none(), "并发已删的 Account-Session 应保持已删");
}
#[tokio::test]
async fn account_guard_reread_corrupt_keeps_record() {
let dao = ScriptedDao::new();
let session = seed_expired_account_session(&dao, "acct-guard-corrupt").await;
dao.on_get_nth(
account_key("acct-guard-corrupt"),
2,
GetAction::Rewrite("nonsense-json"),
);
let live = session
.get_account_session("acct-guard-corrupt")
.await
.unwrap();
assert!(live.is_none());
let stored = dao
.inner
.get(&account_key("acct-guard-corrupt"))
.await
.unwrap();
assert!(stored.is_some(), "损坏的 Account-Session 不由守卫删除");
}
#[tokio::test]
async fn account_guard_delete_error_keeps_record() {
let dao = ScriptedDao::new();
dao.fail_delete_on(account_key("acct-guard-del-err"));
let session = seed_expired_account_session(&dao, "acct-guard-del-err").await;
let live = session
.get_account_session("acct-guard-del-err")
.await
.unwrap();
assert!(live.is_none());
let stored = dao
.inner
.get(&account_key("acct-guard-del-err"))
.await
.unwrap();
assert!(stored.is_some(), "删除失败时 Account-Session 保留");
}
#[tokio::test]
async fn get_token_session_with_ttl_corrupt_value_errors() {
let (dao, session) = make_session(3600, 86400);
dao.set(&token_key("corrupt-ttl-tok"), "{{{not-json", 3600)
.await
.unwrap();
let err = match session.get_token_session_with_ttl("corrupt-ttl-tok").await {
Err(e) => e,
Ok(v) => panic!("损坏值应报错,实际: {v:?}"),
};
assert!(
matches!(&err, GarrisonError::Session(m) if m.contains("session-sim-token-deserialize")),
"应报 session-sim-token-deserialize,实际: {err:?}"
);
}
#[tokio::test]
async fn get_account_session_corrupt_value_errors() {
let (dao, session) = make_session(3600, 86400);
dao.set(&account_key("acct-corrupt"), "{{{not-json", 86400)
.await
.unwrap();
let err = match session.get_account_session("acct-corrupt").await {
Err(e) => e,
Ok(v) => panic!("损坏值应报错,实际: {v:?}"),
};
assert!(
matches!(&err, GarrisonError::Session(m) if m.contains("session-sim-account-deserialize")),
"应报 session-sim-account-deserialize,实际: {err:?}"
);
}
}