use std::time::Duration;
use serde::{Deserialize, Serialize};
use sisa_caching_core::{
cache::CacheError,
settings::{CacheSettings, NoUnknownFields, check_duration},
};
const MAX_SHARDS: usize = 1_024;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
#[non_exhaustive]
pub struct MemorySettings {
pub purge_interval_secs: Option<u64>,
pub max_entries: Option<usize>,
pub shards: Option<usize>,
}
impl Default for MemorySettings {
fn default() -> Self {
Self {
purge_interval_secs: Some(60),
max_entries: None,
shards: Some(16),
}
}
}
impl MemorySettings {
pub fn validate(&self) -> Result<(), CacheError> {
check_duration(
"purge_interval_secs",
self.purge_interval(),
"use None to turn purging off",
)?;
for (field, count, none) in [
("max_entries", self.max_entries, "for no limit"),
("shards", self.shards, "for one map"),
] {
if count == Some(0) {
return Err(CacheError::invalid_settings(
field,
format!("is 0; use None {none}"),
));
}
}
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 shards(&self) -> usize {
self.shards.unwrap_or(1)
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default)]
#[non_exhaustive]
pub struct InMemoryCacheSettings {
#[serde(flatten)]
pub common: CacheSettings,
#[serde(flatten)]
pub memory: MemorySettings,
#[serde(flatten, skip_serializing)]
pub(crate) unknown_fields: NoUnknownFields,
}
impl Default for InMemoryCacheSettings {
fn default() -> Self {
Self {
common: CacheSettings::default(),
memory: MemorySettings::default(),
unknown_fields: NoUnknownFields,
}
}
}
impl InMemoryCacheSettings {
pub fn validate(&self) -> Result<(), CacheError> {
self.common.validate()?;
self.memory.validate()
}
}
#[cfg(test)]
mod tests {
use sisa_caching_core::settings::MAX_TTL_SECS;
use super::*;
#[test]
fn out_of_range_settings_are_rejected() {
let too_long = Some(MAX_TTL_SECS + 1);
let memory = |memory| InMemoryCacheSettings {
memory,
..InMemoryCacheSettings::default()
};
for (field, settings) in [
(
"default_ttl_secs",
InMemoryCacheSettings {
common: {
let mut settings = CacheSettings::default();
settings.default_ttl_secs = too_long;
settings
},
..InMemoryCacheSettings::default()
},
),
(
"purge_interval_secs",
memory(MemorySettings {
purge_interval_secs: too_long,
..MemorySettings::default()
}),
),
(
"purge_interval_secs",
memory(MemorySettings {
purge_interval_secs: Some(0),
..MemorySettings::default()
}),
),
(
"max_entries",
memory(MemorySettings {
max_entries: Some(0),
..MemorySettings::default()
}),
),
(
"shards",
memory(MemorySettings {
shards: Some(0),
..MemorySettings::default()
}),
),
(
"shards",
memory(MemorySettings {
shards: Some(MAX_SHARDS + 1),
..MemorySettings::default()
}),
),
] {
assert!(
matches!(settings.validate(), Err(CacheError::InvalidSettings { field: rejected, .. }) if rejected == field),
"{settings:?}"
);
}
let year = Some(MAX_TTL_SECS);
let settings = InMemoryCacheSettings {
common: {
let mut settings = CacheSettings::default();
settings.default_ttl_secs = year;
settings
},
memory: MemorySettings {
purge_interval_secs: year,
shards: Some(MAX_SHARDS),
..MemorySettings::default()
},
..InMemoryCacheSettings::default()
};
assert!(
settings.validate().is_ok(),
"exactly 365 days and 1,024 maps are allowed"
);
}
#[test]
fn by_default_purging_runs_every_minute_nothing_is_capped_and_there_are_16_maps() {
let settings = InMemoryCacheSettings::default();
assert_eq!(settings.common, CacheSettings::default());
assert_eq!(
settings.memory.purge_interval(),
Some(Duration::from_secs(60))
);
assert_eq!(settings.memory.max_entries, None);
assert_eq!(settings.memory.shards(), 16);
}
#[test]
fn none_turns_a_limit_off() {
let settings = MemorySettings {
purge_interval_secs: None,
max_entries: None,
shards: None,
};
assert!(settings.validate().is_ok());
assert_eq!(settings.purge_interval(), None);
assert_eq!(settings.max_entries, None);
assert_eq!(settings.shards(), 1);
}
}