use std::time::Duration;
use serde::{Deserialize, Serialize};
use sisa_caching_core::{
cache::CacheError,
settings::{CacheSettings, MAX_TTL_SECS},
};
const MAX_SHARDS: usize = 1_024;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct InMemoryCacheSettings {
pub common: CacheSettings,
pub purge_interval_secs: Option<u64>,
pub max_entries: Option<usize>,
pub max_ttl_secs: Option<u64>,
pub shards: Option<usize>,
}
impl Default for InMemoryCacheSettings {
fn default() -> Self {
Self {
common: CacheSettings::default(),
purge_interval_secs: Some(60),
max_entries: None,
max_ttl_secs: None,
shards: None,
}
}
}
impl InMemoryCacheSettings {
pub fn validate(&self) -> Result<(), CacheError> {
self.common.validate()?;
for (field, zero, none) in [
(
"purge_interval_secs",
self.purge_interval_secs == Some(0),
"to turn purging off",
),
("max_entries", self.max_entries == Some(0), "for no limit"),
("max_ttl_secs", self.max_ttl_secs == Some(0), "for no cap"),
("shards", self.shards == Some(0), "for one map"),
] {
if zero {
return Err(CacheError::invalid_settings(
field,
format!("is 0; use None {none}"),
));
}
}
for (field, secs) in [
("purge_interval_secs", self.purge_interval_secs),
("max_ttl_secs", self.max_ttl_secs),
] {
if let Some(secs) = secs.filter(|secs| *secs > MAX_TTL_SECS) {
return Err(CacheError::too_long(field, secs));
}
}
if let Some(shards) = self.shards.filter(|shards| *shards > MAX_SHARDS) {
return Err(CacheError::invalid_settings(
"shards",
format!("is {shards}; the most is {MAX_SHARDS}"),
));
}
Ok(())
}
pub fn purge_interval(&self) -> Option<Duration> {
self.purge_interval_secs.map(Duration::from_secs)
}
pub fn max_entries(&self) -> Option<usize> {
self.max_entries
}
pub fn shards(&self) -> usize {
self.shards.unwrap_or(1)
}
pub fn max_ttl(&self) -> Option<Duration> {
self.max_ttl_secs.map(Duration::from_secs)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn durations_over_365_days_are_rejected() {
let too_long = Some(MAX_TTL_SECS + 1);
for (field, settings) in [
(
"ttl_secs",
InMemoryCacheSettings {
common: CacheSettings {
ttl_secs: too_long,
..CacheSettings::default()
},
..InMemoryCacheSettings::default()
},
),
(
"purge_interval_secs",
InMemoryCacheSettings {
purge_interval_secs: too_long,
..InMemoryCacheSettings::default()
},
),
(
"max_ttl_secs",
InMemoryCacheSettings {
max_ttl_secs: too_long,
..InMemoryCacheSettings::default()
},
),
] {
assert!(
matches!(settings.validate(), Err(CacheError::InvalidSettings { field: f, .. }) if f == field),
"{field}"
);
}
let year = Some(MAX_TTL_SECS);
let settings = InMemoryCacheSettings {
common: CacheSettings {
ttl_secs: year,
..CacheSettings::default()
},
purge_interval_secs: year,
max_ttl_secs: year,
..InMemoryCacheSettings::default()
};
assert!(settings.validate().is_ok(), "exactly 365 days is allowed");
}
#[test]
fn by_default_purging_runs_every_minute_and_nothing_is_capped() {
let settings = InMemoryCacheSettings::default();
assert_eq!(settings.purge_interval(), Some(Duration::from_secs(60)));
assert_eq!(settings.max_entries(), None);
assert_eq!(settings.max_ttl(), None);
}
#[test]
fn none_turns_a_limit_off() {
let settings = InMemoryCacheSettings {
purge_interval_secs: None,
max_entries: None,
max_ttl_secs: None,
shards: None,
..InMemoryCacheSettings::default()
};
assert!(settings.validate().is_ok());
assert_eq!(settings.purge_interval(), None);
assert_eq!(settings.max_entries(), None);
assert_eq!(settings.max_ttl(), None);
assert_eq!(settings.shards(), 1);
}
#[test]
fn zero_is_rejected() {
for (field, settings) in [
(
"purge_interval_secs",
InMemoryCacheSettings {
purge_interval_secs: Some(0),
..InMemoryCacheSettings::default()
},
),
(
"max_entries",
InMemoryCacheSettings {
max_entries: Some(0),
..InMemoryCacheSettings::default()
},
),
(
"max_ttl_secs",
InMemoryCacheSettings {
max_ttl_secs: Some(0),
..InMemoryCacheSettings::default()
},
),
(
"shards",
InMemoryCacheSettings {
shards: Some(0),
..InMemoryCacheSettings::default()
},
),
] {
assert!(
matches!(settings.validate(), Err(CacheError::InvalidSettings { field: f, .. }) if f == field),
"{field}"
);
}
}
#[test]
fn more_than_1024_shards_are_rejected() {
let shards = |shards| InMemoryCacheSettings {
shards: Some(shards),
..InMemoryCacheSettings::default()
};
assert!(shards(MAX_SHARDS).validate().is_ok());
assert!(matches!(
shards(MAX_SHARDS + 1).validate(),
Err(CacheError::InvalidSettings {
field: "shards",
..
})
));
}
}