use std::time::Duration;
use serde::{Deserialize, Serialize};
use sisa_caching_core::{
cache::CacheError,
settings::{CacheSettings, MAX_TTL_SECS},
};
#[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, 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));
}
}
Ok(())
}
pub fn purge_interval(&self) -> Option<Duration> {
self.purge_interval_secs
.filter(|secs| *secs > 0)
.map(Duration::from_secs)
}
pub fn max_entries(&self) -> Option<usize> {
self.max_entries.filter(|max| *max > 0)
}
pub fn shards(&self) -> usize {
self.shards.filter(|shards| *shards > 0).unwrap_or(1)
}
pub fn max_ttl(&self) -> Option<Duration> {
self.max_ttl_secs
.filter(|secs| *secs > 0)
.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 zero_turns_a_limit_off() {
let settings = InMemoryCacheSettings {
purge_interval_secs: Some(0),
max_entries: Some(0),
max_ttl_secs: Some(0),
shards: Some(0),
..InMemoryCacheSettings::default()
};
assert_eq!(settings.purge_interval(), None);
assert_eq!(settings.max_entries(), None);
assert_eq!(settings.max_ttl(), None);
assert_eq!(settings.shards(), 1);
}
}