use actix::prelude::*;
use tokio::sync::oneshot;
use super::messages::*;
use super::AddChallenge;
use super::Save;
use crate::errors::*;
use crate::redis::mcaptcha_redis::MCaptchaRedis;
use crate::redis::RedisConfig;
pub struct RedisCache(MCaptchaRedis);
impl RedisCache {
pub async fn new(redis: RedisConfig) -> CaptchaResult<Self> {
let redis = MCaptchaRedis::new(redis).await?;
let master = Self(redis);
Ok(master)
}
}
impl Save for RedisCache {}
impl Actor for RedisCache {
type Context = Context<Self>;
}
impl Handler<CachePoW> for RedisCache {
type Result = MessageResult<CachePoW>;
fn handle(&mut self, msg: CachePoW, ctx: &mut Self::Context) -> Self::Result {
let (tx, rx) = oneshot::channel();
let con = self.0.get_client();
let fut = async move {
let payload: AddChallenge = AddChallenge {
challenge: msg.string,
difficulty: msg.difficulty_factor,
duration: msg.duration,
};
let res = con.add_challenge(&msg.key, &payload).await;
tx.send(res).unwrap();
}
.into_actor(self);
ctx.wait(fut);
MessageResult(rx)
}
}
impl Handler<RetrivePoW> for RedisCache {
type Result = MessageResult<RetrivePoW>;
fn handle(&mut self, msg: RetrivePoW, ctx: &mut Self::Context) -> Self::Result {
let (tx, rx) = oneshot::channel();
let con = self.0.get_client();
let fut = async move {
let r = match con.get_challenge(&msg.0).await {
Err(e) => Err(e),
Ok(val) => {
let res = CachedPoWConfig {
duration: val.duration,
difficulty_factor: val.difficulty_factor,
key: msg.0.key,
};
Ok(Some(res))
}
};
tx.send(r).unwrap();
}
.into_actor(self);
ctx.wait(fut);
MessageResult(rx)
}
}
impl Handler<CacheResult> for RedisCache {
type Result = MessageResult<CacheResult>;
fn handle(&mut self, msg: CacheResult, ctx: &mut Self::Context) -> Self::Result {
let (tx, rx) = oneshot::channel();
let con = self.0.get_client();
let fut = async move {
let r = con.add_token(&msg).await;
tx.send(r).unwrap();
}
.into_actor(self);
ctx.wait(fut);
MessageResult(rx)
}
}
impl Handler<VerifyCaptchaResult> for RedisCache {
type Result = MessageResult<VerifyCaptchaResult>;
fn handle(&mut self, msg: VerifyCaptchaResult, ctx: &mut Self::Context) -> Self::Result {
let (tx, rx) = oneshot::channel();
let con = self.0.get_client();
let fut = async move {
let r = con.get_token(&msg).await;
tx.send(r).unwrap();
}
.into_actor(self);
ctx.wait(fut);
MessageResult(rx)
}
}
impl Handler<DeleteCaptchaResult> for RedisCache {
type Result = MessageResult<DeleteCaptchaResult>;
fn handle(&mut self, _msg: DeleteCaptchaResult, _ctx: &mut Self::Context) -> Self::Result {
MessageResult(Ok(()))
}
}
impl Handler<DeletePoW> for RedisCache {
type Result = MessageResult<DeletePoW>;
fn handle(&mut self, _msg: DeletePoW, _ctx: &mut Self::Context) -> Self::Result {
MessageResult(Ok(()))
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::time::Duration;
use actix::clock::sleep;
const REDIS_URL: &str = "redis://127.0.1.1/";
#[actix_rt::test]
async fn rediscache_pow_cache_works() {
const DIFFICULTY_FACTOR: u32 = 54;
const DURATION: u64 = 5;
const KEY: &str = "mcaptchakey";
const CHALLENGE: &str = "redischallenge1";
let addr = RedisCache::new(RedisConfig::Single(REDIS_URL.into()))
.await
.unwrap()
.start();
let msg = CachePoWBuilder::default()
.string(CHALLENGE.into())
.difficulty_factor(DIFFICULTY_FACTOR)
.duration(DURATION)
.key(KEY.into())
.build()
.unwrap();
addr.send(msg.clone())
.await
.unwrap()
.await
.unwrap()
.unwrap();
let msg = VerifyCaptchaResult {
token: CHALLENGE.into(),
key: KEY.into(),
};
let cache_difficulty_factor = addr
.send(RetrivePoW(msg.clone()))
.await
.unwrap()
.await
.unwrap()
.unwrap();
assert_eq!(
DIFFICULTY_FACTOR,
cache_difficulty_factor.unwrap().difficulty_factor
);
let duration: Duration = Duration::new(5, 0);
sleep(duration + duration).await;
let expired_string = addr.send(RetrivePoW(msg)).await.unwrap().await.unwrap();
assert!(expired_string.is_err());
}
#[actix_rt::test]
async fn redishashcache_result_cache_works() {
use std::time::Duration;
const DURATION: u64 = 5;
const KEY: &str = "a";
const RES: &str = "b";
let addr = RedisCache::new(RedisConfig::Single(REDIS_URL.into()))
.await
.unwrap()
.start();
let add_cache = CacheResult {
key: KEY.into(),
token: RES.into(),
duration: DURATION,
};
addr.send(add_cache).await.unwrap().await.unwrap().unwrap();
let verify_msg = VerifyCaptchaResult {
key: KEY.into(),
token: RES.into(),
};
assert!(addr
.send(verify_msg.clone())
.await
.unwrap()
.await
.unwrap()
.unwrap());
assert!(!addr.send(verify_msg).await.unwrap().await.unwrap().unwrap());
let verify_msg = VerifyCaptchaResult {
key: "cz".into(),
token: RES.into(),
};
assert!(!addr.send(verify_msg).await.unwrap().await.unwrap().unwrap());
let duration: Duration = Duration::new(5, 0);
sleep(duration + duration).await;
let verify_msg = VerifyCaptchaResult {
key: KEY.into(),
token: RES.into(),
};
assert!(!addr.send(verify_msg).await.unwrap().await.unwrap().unwrap());
}
}