amnesia 0.1.5

An expressive interface for interacting with a Cache.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use super::Driver;
use redis::AsyncCommands;
use serde::{de::DeserializeOwned, Serialize};
use std::time::Duration;

pub struct Config {
	pub prefix: String,
	pub redis_url: String,
}

impl Default for Config {
	fn default() -> Self {
		Self {
			prefix: String::new(),
			redis_url: "redis://localhost".to_string(),
		}
	}
}

#[allow(clippy::module_name_repetitions)]
/// A driver that uses Redis.
pub struct RedisDriver {
	prefix: String,
	client: redis::Client,
}

impl Driver for RedisDriver {
	type Error = Error;
	type Config = Config;

	async fn new(config: Self::Config) -> Result<Self, Self::Error> {
		Ok(Self {
			prefix: config.prefix,
			client: redis::Client::open(config.redis_url)?,
		})
	}

	async fn get<T: DeserializeOwned>(&self, key: &str) -> Result<Option<T>, Self::Error> {
		let mut conn = self.client.get_async_connection().await?;

		let Some(data) = conn
			.get::<_, Option<Vec<u8>>>(format!("{}{key}", self.prefix))
			.await?
		else {
			return Ok(None);
		};

		Ok(Some(bitcode::deserialize(&data)?))
	}

	async fn has(&self, key: &str) -> Result<bool, Self::Error> {
		let mut conn = self.client.get_async_connection().await?;

		Ok(conn.exists(format!("{}{key}", self.prefix)).await?)
	}

	async fn put<T: Serialize + Sync>(
		&mut self,
		key: &str,
		value: &T,
		expiry: Option<Duration>,
	) -> Result<(), Self::Error> {
		let mut conn = self.client.get_async_connection().await?;
		let data = bitcode::serialize(value)?;

		if let Some(expiry) = expiry {
			conn.set_ex(format!("{}{key}", self.prefix), data, expiry.as_secs())
				.await?;
		} else {
			conn.set(format!("{}{key}", self.prefix), data).await?;
		}

		Ok(())
	}

	async fn forget(&mut self, key: &str) -> Result<(), Self::Error> {
		let mut conn = self.client.get_async_connection().await?;
		conn.del(format!("{}{key}", self.prefix)).await?;

		Ok(())
	}

	async fn flush(&mut self) -> Result<(), Self::Error> {
		let mut conn = self.client.get_async_connection().await?;
		redis::cmd("FLUSHDB").query_async(&mut conn).await?;

		Ok(())
	}
}

#[derive(Debug, thiserror::Error)]
pub enum Error {
	#[error(transparent)]
	Redis(#[from] redis::RedisError),
	#[error(transparent)]
	Serialization(#[from] bitcode::Error),
}

#[cfg(test)]
mod tests {
	use std::env;

	use super::*;
	use crate::Cache;

	#[tokio::test]
	async fn test_redis_driver() {
		let mut cache = Cache::<RedisDriver>::new(Config {
			redis_url: env::var("REDIS_URL").expect("REDIS_URL not set"),
			..Default::default()
		})
		.await
		.unwrap();

		assert_eq!(cache.get::<String>("foo").await.unwrap(), None);
		assert!(!cache.has("foo").await.unwrap());

		cache
			.put("foo", &"bar", Duration::from_secs(1))
			.await
			.unwrap();

		assert_eq!(
			cache.get::<String>("foo").await.unwrap(),
			Some("bar".to_string())
		);
		assert!(cache.has("foo").await.unwrap());

		cache.forget("foo").await.unwrap();

		assert_eq!(cache.get::<String>("foo").await.unwrap(), None);
		assert!(!cache.has("foo").await.unwrap());
	}
}