use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
pub mod strategy;
#[cfg(test)]
pub mod tests;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum WaitStrategy {
Multiple {
base_seconds: u64,
multiplier: u32,
},
Linear {
base_seconds: u64,
},
}
#[derive(Debug, Clone)]
pub struct UserLockoutConfig {
pub max_failure_factor: u32,
pub permanent_lockout: bool,
pub max_temporary_lockouts: u32,
pub wait_strategy: WaitStrategy,
pub failure_window_seconds: u64,
}
impl UserLockoutConfig {
pub fn validate(&self) -> GarrisonResult<()> {
if self.max_failure_factor == 0 {
return Err(GarrisonError::Config(
"lockout-config-max-failure-factor-zero::".to_string(),
));
}
if self.failure_window_seconds == 0 {
return Err(GarrisonError::Config(
"lockout-config-failure-window-zero::".to_string(),
));
}
if self.permanent_lockout && self.max_temporary_lockouts == 0 {
return Err(GarrisonError::Config(
"lockout-config-max-temporary-lockouts-zero::".to_string(),
));
}
match &self.wait_strategy {
WaitStrategy::Multiple {
base_seconds,
multiplier,
} => {
if *base_seconds == 0 || *multiplier == 0 {
return Err(GarrisonError::Config(
"lockout-config-wait-strategy-zero::".to_string(),
));
}
},
WaitStrategy::Linear { base_seconds } => {
if *base_seconds == 0 {
return Err(GarrisonError::Config(
"lockout-config-wait-strategy-zero::".to_string(),
));
}
},
}
Ok(())
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct LockoutState {
pub failure_count: u32,
pub temporary_lockout_count: u32,
pub permanent_locked: bool,
pub locked_until: i64,
#[serde(skip_serializing_if = "Option::is_none")]
pub first_failure_at: Option<i64>,
}
pub struct UserLockoutStrategy {
pub(super) config: UserLockoutConfig,
pub(super) dao: Arc<dyn GarrisonDao>,
#[cfg(feature = "metrics-prometheus")]
pub(super) metrics: Option<Arc<crate::account::metrics::AccountMetrics>>,
}