use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use crate::limiteron::GarrisonDaoDistributedLimiter;
use limiteron::limiters::DistributedLimiter;
use std::sync::Arc;
use std::time::Duration;
const ATTEMPT_KEY_PREFIX: &str = "garrison:invitation:attempt:";
pub struct InvitationAttemptLimiter {
pub(crate) limiter: GarrisonDaoDistributedLimiter,
pub(crate) max_attempts: u32,
pub(crate) window_seconds: u64,
}
impl InvitationAttemptLimiter {
pub fn new(dao: Arc<dyn GarrisonDao>) -> Self {
Self::with_config(dao, 10, 600)
}
pub fn with_config(dao: Arc<dyn GarrisonDao>, max_attempts: u32, window_seconds: u64) -> Self {
Self {
limiter: GarrisonDaoDistributedLimiter::new(dao),
max_attempts,
window_seconds,
}
}
pub async fn check(&self, source: &str) -> GarrisonResult<()> {
let key = format!("{}{}", ATTEMPT_KEY_PREFIX, source_digest_hex(source));
let count = self
.limiter
.incr_with_ttl(&key, 1, Duration::from_secs(self.window_seconds))
.await
.map_err(|e| GarrisonError::Dao(format!("invitation-incr-ttl::{}", e)))?;
if count > self.max_attempts as u64 {
return Err(GarrisonError::InvalidParam(format!(
"invitation-too-many-attempts::{}",
source
)));
}
Ok(())
}
pub async fn reset(&self, source: &str) -> GarrisonResult<()> {
let key = format!("{}{}", ATTEMPT_KEY_PREFIX, source_digest_hex(source));
self.limiter
.reset(&key)
.await
.map_err(|e| GarrisonError::Dao(format!("invitation-reset::{}", e)))
}
}
fn source_digest_hex(source: &str) -> String {
use sha2::{Digest, Sha256};
use std::fmt::Write;
let mut hasher = Sha256::new();
hasher.update(source.as_bytes());
let digest = hasher.finalize();
let mut out = String::with_capacity(64);
for byte in digest {
let _ = write!(out, "{:02x}", byte);
}
out
}