1use std::time::Duration;
4
5use serde::{Deserialize, Serialize};
6use sisa_caching_core::{
7 cache::CacheError,
8 settings::{CacheSettings, NoUnknownFields, check_duration},
9};
10
11const MAX_SHARDS: usize = 1_024;
13
14#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
17#[serde(default, deny_unknown_fields)]
18#[non_exhaustive]
19pub struct MemorySettings {
20 pub purge_interval_secs: Option<u64>,
23
24 pub max_entries: Option<usize>,
30
31 pub shards: Option<usize>,
37}
38
39impl Default for MemorySettings {
41 fn default() -> Self {
42 Self {
43 purge_interval_secs: Some(60),
44 max_entries: None,
45 shards: Some(16),
46 }
47 }
48}
49
50impl MemorySettings {
51 pub fn validate(&self) -> Result<(), CacheError> {
54 check_duration(
55 "purge_interval_secs",
56 self.purge_interval(),
57 "use None to turn purging off",
58 )?;
59
60 for (field, count, none) in [
61 ("max_entries", self.max_entries, "for no limit"),
62 ("shards", self.shards, "for one map"),
63 ] {
64 if count == Some(0) {
65 return Err(CacheError::invalid_settings(
66 field,
67 format!("is 0; use None {none}"),
68 ));
69 }
70 }
71
72 if let Some(shards) = self.shards.filter(|shards| *shards > MAX_SHARDS) {
73 return Err(CacheError::invalid_settings(
74 "shards",
75 format!("is {shards}; the most is {MAX_SHARDS}"),
76 ));
77 }
78
79 Ok(())
80 }
81
82 pub fn purge_interval(&self) -> Option<Duration> {
84 self.purge_interval_secs.map(Duration::from_secs)
85 }
86
87 pub fn shards(&self) -> usize {
89 self.shards.unwrap_or(1)
90 }
91}
92
93#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
108#[serde(default)]
109#[non_exhaustive]
110pub struct InMemoryCacheSettings {
111 #[serde(flatten)]
113 pub common: CacheSettings,
114
115 #[serde(flatten)]
117 pub memory: MemorySettings,
118
119 #[serde(flatten, skip_serializing)]
121 pub(crate) unknown_fields: NoUnknownFields,
122}
123
124impl Default for InMemoryCacheSettings {
126 fn default() -> Self {
127 Self {
128 common: CacheSettings::default(),
129 memory: MemorySettings::default(),
130 unknown_fields: NoUnknownFields,
131 }
132 }
133}
134
135impl InMemoryCacheSettings {
136 pub fn validate(&self) -> Result<(), CacheError> {
139 self.common.validate()?;
140 self.memory.validate()
141 }
142}
143
144#[cfg(test)]
145mod tests {
146 use sisa_caching_core::settings::MAX_TTL_SECS;
147
148 use super::*;
149
150 #[test]
151 fn out_of_range_settings_are_rejected() {
152 let too_long = Some(MAX_TTL_SECS + 1);
153 let memory = |memory| InMemoryCacheSettings {
154 memory,
155 ..InMemoryCacheSettings::default()
156 };
157
158 for (field, settings) in [
159 (
160 "default_ttl_secs",
161 InMemoryCacheSettings {
162 common: {
163 let mut settings = CacheSettings::default();
164 settings.default_ttl_secs = too_long;
165 settings
166 },
167 ..InMemoryCacheSettings::default()
168 },
169 ),
170 (
171 "purge_interval_secs",
172 memory(MemorySettings {
173 purge_interval_secs: too_long,
174 ..MemorySettings::default()
175 }),
176 ),
177 (
178 "purge_interval_secs",
179 memory(MemorySettings {
180 purge_interval_secs: Some(0),
181 ..MemorySettings::default()
182 }),
183 ),
184 (
185 "max_entries",
186 memory(MemorySettings {
187 max_entries: Some(0),
188 ..MemorySettings::default()
189 }),
190 ),
191 (
192 "shards",
193 memory(MemorySettings {
194 shards: Some(0),
195 ..MemorySettings::default()
196 }),
197 ),
198 (
199 "shards",
200 memory(MemorySettings {
201 shards: Some(MAX_SHARDS + 1),
202 ..MemorySettings::default()
203 }),
204 ),
205 ] {
206 assert!(
207 matches!(settings.validate(), Err(CacheError::InvalidSettings { field: rejected, .. }) if rejected == field),
208 "{settings:?}"
209 );
210 }
211
212 let year = Some(MAX_TTL_SECS);
213 let settings = InMemoryCacheSettings {
214 common: {
215 let mut settings = CacheSettings::default();
216 settings.default_ttl_secs = year;
217 settings
218 },
219 memory: MemorySettings {
220 purge_interval_secs: year,
221 shards: Some(MAX_SHARDS),
222 ..MemorySettings::default()
223 },
224 ..InMemoryCacheSettings::default()
225 };
226
227 assert!(
228 settings.validate().is_ok(),
229 "exactly 365 days and 1,024 maps are allowed"
230 );
231 }
232
233 #[test]
234 fn by_default_purging_runs_every_minute_nothing_is_capped_and_there_are_16_maps() {
235 let settings = InMemoryCacheSettings::default();
236
237 assert_eq!(settings.common, CacheSettings::default());
238 assert_eq!(
239 settings.memory.purge_interval(),
240 Some(Duration::from_secs(60))
241 );
242 assert_eq!(settings.memory.max_entries, None);
243 assert_eq!(settings.memory.shards(), 16);
244 }
245
246 #[test]
247 fn none_turns_a_limit_off() {
248 let settings = MemorySettings {
249 purge_interval_secs: None,
250 max_entries: None,
251 shards: None,
252 };
253
254 assert!(settings.validate().is_ok());
255 assert_eq!(settings.purge_interval(), None);
256 assert_eq!(settings.max_entries, None);
257 assert_eq!(settings.shards(), 1);
258 }
259}