use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
#[cfg(feature = "listener")]
use crate::listener::{GarrisonEvent, GarrisonListenerManager};
use std::sync::Arc;
use uuid::Uuid;
use super::TempCredentialHandler;
impl TempCredentialHandler {
pub fn new(dao: Arc<dyn GarrisonDao>) -> Self {
Self {
dao,
#[cfg(feature = "listener")]
listener_manager: None,
}
}
#[cfg(feature = "listener")]
pub fn with_listener_manager(mut self, lm: Arc<GarrisonListenerManager>) -> Self {
self.listener_manager = Some(lm);
self
}
pub async fn issue(
&self,
prefix: &str,
value: &str,
ttl_seconds: i64,
) -> GarrisonResult<String> {
if prefix.contains(':') {
return Err(GarrisonError::InvalidParam(
"temp-prefix-colon::".to_string(),
));
}
if ttl_seconds <= 0 {
return Err(GarrisonError::InvalidParam(
"temp-ttl-invalid::".to_string(),
));
}
let random = format!("{}{}", Uuid::new_v4().simple(), Uuid::new_v4().simple());
let key = format!("garrison:temp:{}:{}", prefix, random);
self.dao.set(&key, value, ttl_seconds as u64).await?;
Ok(key)
}
pub async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
self.dao.get(key).await
}
pub async fn revoke(&self, key: &str) -> GarrisonResult<()> {
self.dao.delete(key).await
}
pub async fn consume(&self, key: &str) -> GarrisonResult<Option<String>> {
let value = self.dao.get_and_delete(key).await?;
#[cfg(feature = "listener")]
if let Some(lm) = &self.listener_manager {
if let Some(ref v) = value {
lm.broadcast(&GarrisonEvent::TempCredentialConsumed {
key: key.to_string(),
value: v.clone(),
request_context: None,
})
.await;
}
}
Ok(value)
}
}