use crate::errors::{BusRequestError, BusRequestErrorCode, SemiontError};
use crate::state_unit::StateUnit;
use crate::storage::SessionStorage;
use crate::transport::BoxFuture;
use serde::Serialize;
use serde::de::DeserializeOwned;
use serde_json::Value;
use std::collections::{HashMap, HashSet};
use std::future::Future;
use std::hash::Hash;
use std::marker::PhantomData;
use std::sync::{Arc, Mutex, MutexGuard, Weak};
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use tokio::sync::watch;
use tokio::task::AbortHandle;
use tokio_stream::wrappers::WatchStream;
#[derive(Debug, Clone)]
pub enum CacheState<T> {
Pending,
Ready(T),
Failed(Arc<dyn std::error::Error + Send + Sync>),
}
impl<T: PartialEq> PartialEq for CacheState<T> {
fn eq(&self, other: &CacheState<T>) -> bool {
match (self, other) {
(CacheState::Pending, CacheState::Pending) => true,
(CacheState::Ready(one), CacheState::Ready(other)) => one == other,
(CacheState::Failed(one), CacheState::Failed(other)) => Arc::ptr_eq(one, other),
_ => false,
}
}
}
impl<T> CacheState<T> {
pub fn ready(&self) -> Option<&T> {
match self {
CacheState::Ready(value) => Some(value),
CacheState::Pending | CacheState::Failed(_) => None,
}
}
pub fn is_ready(&self) -> bool {
self.ready().is_some()
}
pub fn map<U>(self, view: impl FnOnce(T) -> U) -> CacheState<U> {
match self {
CacheState::Pending => CacheState::Pending,
CacheState::Ready(value) => CacheState::Ready(view(value)),
CacheState::Failed(error) => CacheState::Failed(error),
}
}
}
pub trait CacheKey: Clone + Eq + Hash + Send + Sync + 'static {}
impl<K: Clone + Eq + Hash + Send + Sync + 'static> CacheKey for K {}
pub trait CacheValue: Clone + Send + Sync + 'static {}
impl<V: Clone + Send + Sync + 'static> CacheValue for V {}
pub trait CachePersister<K, V>: Send + Sync + 'static {
fn load(&self) -> Option<HashMap<K, V>>;
fn save(&self, entries: &HashMap<K, V>)
-> Result<(), Box<dyn std::error::Error + Send + Sync>>;
}
fn saved<K: CacheKey, V: CacheValue>(
persister: &dyn CachePersister<K, V>,
entries: &HashMap<K, V>,
) {
if let Err(unsaved) = persister.save(entries) {
log::warn!("semiont: the cache's values were not kept: {unsaved}");
}
}
type Fetch<K, V> = dyn Fn(K) -> BoxFuture<'static, Result<V, Arc<dyn std::error::Error + Send + Sync>>>
+ Send
+ Sync;
type Outcome<V> = watch::Receiver<Option<Result<V, Arc<dyn std::error::Error + Send + Sync>>>>;
struct Key<V> {
state: watch::Sender<CacheState<V>>,
in_flight: Option<(u64, Outcome<V>)>,
}
impl<V> Key<V> {
fn new(state: CacheState<V>) -> Key<V> {
Key {
state: watch::channel(state).0,
in_flight: None,
}
}
fn known(&self) -> bool {
self.in_flight.is_some() || !matches!(*self.state.borrow(), CacheState::Pending)
}
}
struct State<K, V> {
disposed: bool,
keys: HashMap<K, Key<V>>,
kept: HashSet<K>,
fetches: u64,
saving: Option<AbortHandle>,
}
struct Inner<K, V>
where
K: CacheKey,
V: CacheValue,
{
fetch: Box<Fetch<K, V>>,
persister: Option<Arc<dyn CachePersister<K, V>>>,
save_debounce: Duration,
state: Mutex<State<K, V>>,
}
fn closed() -> Arc<dyn std::error::Error + Send + Sync> {
Arc::new(SemiontError::from(BusRequestError::new(
BusRequestErrorCode::Closed,
"The client is closed",
)))
}
async fn outcome<V: Clone>(
mut of: Outcome<V>,
) -> Result<V, Arc<dyn std::error::Error + Send + Sync>> {
loop {
if let Some(outcome) = of.borrow_and_update().clone() {
return outcome;
}
if of.changed().await.is_err() {
return Err(closed());
}
}
}
impl<K, V> Inner<K, V>
where
K: CacheKey,
V: CacheValue,
{
fn state(&self) -> MutexGuard<'_, State<K, V>> {
self.state
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
}
fn values(state: &State<K, V>) -> HashMap<K, V> {
state
.keys
.iter()
.filter_map(|(key, held)| {
held.state
.borrow()
.ready()
.map(|value| (key.clone(), value.clone()))
})
.collect()
}
fn owe_a_save(self: &Arc<Self>, state: &mut State<K, V>) {
if self.persister.is_none() || state.disposed {
return;
}
if let Some(waiting) = state.saving.take() {
waiting.abort();
}
let cache = Arc::downgrade(self);
let wait = self.save_debounce;
state.saving = Some(
tokio::spawn(async move {
tokio::time::sleep(wait).await;
if let Some(cache) = Weak::upgrade(&cache) {
let entries = {
let mut state = cache.state();
state.saving = None;
Inner::values(&state)
};
if let Some(persister) = &cache.persister {
saved(persister.as_ref(), &entries);
}
}
})
.abort_handle(),
);
}
fn fetching(self: &Arc<Self>, key: &K) -> Outcome<V> {
let mut state = self.state();
state.kept.remove(key);
state.fetches += 1;
let number = state.fetches;
let held = state
.keys
.entry(key.clone())
.or_insert_with(|| Key::new(CacheState::Pending));
if let Some((_, in_flight)) = &held.in_flight {
return in_flight.clone();
}
let (answered, outcome) = watch::channel(None);
held.in_flight = Some((number, outcome.clone()));
drop(state);
let cache = self.clone();
let key = key.clone();
tokio::spawn(async move {
let fetched = (cache.fetch)(key.clone()).await;
{
let mut state = cache.state();
let changed = match state.keys.get_mut(&key) {
Some(held) => {
if held.in_flight.as_ref().is_some_and(|(of, _)| *of == number) {
held.in_flight = None;
}
match &fetched {
Ok(value) => {
held.state.send_replace(CacheState::Ready(value.clone()));
true
}
Err(_) => false,
}
}
None => false,
};
if changed {
cache.owe_a_save(&mut state);
}
}
let _ = answered.send(Some(fetched));
});
outcome
}
fn revalidate(self: &Arc<Self>, key: &K) {
let cache = self.clone();
let key = key.clone();
let first = self.fetching(&key);
tokio::spawn(async move {
if outcome(first).await.is_ok() || cache.state().disposed {
return;
}
let Err(failure) = outcome(cache.fetching(&key)).await else {
return;
};
let state = cache.state();
if let Some(held) = state.keys.get(&key)
&& !held.state.borrow().is_ready()
{
held.state.send_replace(CacheState::Failed(failure));
}
});
}
}
impl<K, V> Drop for Inner<K, V>
where
K: CacheKey,
V: CacheValue,
{
fn drop(&mut self) {
let state = self
.state
.get_mut()
.unwrap_or_else(|poisoned| poisoned.into_inner());
if let Some(waiting) = state.saving.take() {
waiting.abort();
if let Some(persister) = &self.persister {
saved(persister.as_ref(), &Inner::values(state));
}
}
}
}
pub struct Cache<K: CacheKey, V: CacheValue> {
inner: Arc<Inner<K, V>>,
}
impl<K: CacheKey, V: CacheValue> Clone for Cache<K, V> {
fn clone(&self) -> Cache<K, V> {
Cache {
inner: self.inner.clone(),
}
}
}
impl<K, V> Cache<K, V>
where
K: CacheKey,
V: CacheValue,
{
pub fn new<F, Fut>(fetch: F) -> Cache<K, V>
where
F: Fn(K) -> Fut + Send + Sync + 'static,
Fut: Future<Output = Result<V, Box<dyn std::error::Error + Send + Sync>>> + Send + 'static,
{
Cache::build(fetch, None, crate::timing::SAVE_DEBOUNCE)
}
pub fn persisted<F, Fut>(
fetch: F,
persister: Arc<dyn CachePersister<K, V>>,
save_debounce: Duration,
) -> Cache<K, V>
where
F: Fn(K) -> Fut + Send + Sync + 'static,
Fut: Future<Output = Result<V, Box<dyn std::error::Error + Send + Sync>>> + Send + 'static,
{
Cache::build(fetch, Some(persister), save_debounce)
}
fn build<F, Fut>(
fetch: F,
persister: Option<Arc<dyn CachePersister<K, V>>>,
save_debounce: Duration,
) -> Cache<K, V>
where
F: Fn(K) -> Fut + Send + Sync + 'static,
Fut: Future<Output = Result<V, Box<dyn std::error::Error + Send + Sync>>> + Send + 'static,
{
let kept = persister
.as_ref()
.and_then(|persister| persister.load())
.unwrap_or_default();
let inner = Arc::new(Inner {
fetch: Box::new(move |key| {
let fetching = fetch(key);
Box::pin(async move { fetching.await.map_err(Arc::from) })
}),
save_debounce,
state: Mutex::new(State {
disposed: false,
kept: kept.keys().cloned().collect(),
keys: kept
.into_iter()
.map(|(key, value)| (key, Key::new(CacheState::Ready(value))))
.collect(),
fetches: 0,
saving: None,
}),
persister,
});
Cache { inner }
}
pub fn observe(&self, key: &K) -> WatchStream<CacheState<V>> {
let mut state = self.inner.state();
if state.disposed {
return WatchStream::from_changes(watch::channel(CacheState::Pending).1);
}
let was_kept = state.kept.contains(key);
let held = state
.keys
.entry(key.clone())
.or_insert_with(|| Key::new(CacheState::Pending));
let asks = match &*held.state.borrow() {
CacheState::Failed(_) => true,
CacheState::Ready(_) => was_kept,
CacheState::Pending => held.in_flight.is_none(),
};
held.state.send_if_modified(|current| {
let failed = matches!(current, CacheState::Failed(_));
if failed {
*current = CacheState::Pending;
}
failed
});
let observing = WatchStream::new(held.state.subscribe());
drop(state);
if asks {
self.inner.revalidate(key);
}
observing
}
pub fn fetch(
&self,
key: &K,
) -> impl Future<Output = Result<V, Arc<dyn std::error::Error + Send + Sync>>> + Send + 'static
{
let cache = self.inner.clone();
let key = key.clone();
async move {
if cache.state().disposed {
return Err(closed());
}
outcome(cache.fetching(&key)).await
}
}
pub fn get(&self, key: &K) -> Option<V> {
let state = self.inner.state();
let held = state.keys.get(key)?;
held.state.borrow().ready().cloned()
}
pub fn known(&self, key: &K) -> bool {
self.inner.state().keys.get(key).is_some_and(Key::known)
}
pub fn keys(&self) -> Vec<K> {
self.inner
.state()
.keys
.iter()
.filter(|(_, held)| held.known())
.map(|(key, _)| key.clone())
.collect()
}
pub fn invalidate(&self, key: &K) {
{
let mut state = self.inner.state();
if state.disposed {
return;
}
let held = state
.keys
.entry(key.clone())
.or_insert_with(|| Key::new(CacheState::Pending));
held.in_flight = None;
held.state.send_if_modified(|current| {
let failed = matches!(current, CacheState::Failed(_));
if failed {
*current = CacheState::Pending;
}
failed
});
}
self.inner.revalidate(key);
}
pub fn invalidate_all(&self) {
for key in self.keys() {
self.invalidate(&key);
}
}
pub fn remove(&self, key: &K, gone: Box<dyn std::error::Error + Send + Sync>) {
let mut state = self.inner.state();
if state.disposed {
return;
}
state.kept.remove(key);
let held = state
.keys
.entry(key.clone())
.or_insert_with(|| Key::new(CacheState::Pending));
held.in_flight = None;
held.state.send_replace(CacheState::Failed(Arc::from(gone)));
self.inner.owe_a_save(&mut state);
}
pub fn set(&self, key: &K, value: V) {
let mut state = self.inner.state();
if state.disposed {
return;
}
state.kept.remove(key);
state
.keys
.entry(key.clone())
.or_insert_with(|| Key::new(CacheState::Pending))
.state
.send_replace(CacheState::Ready(value));
self.inner.owe_a_save(&mut state);
}
pub fn persistence_pending(&self) -> bool {
let state = self.inner.state();
state.saving.is_some() || state.keys.values().any(|held| held.in_flight.is_some())
}
}
impl<K, V> StateUnit for Cache<K, V>
where
K: CacheKey,
V: CacheValue,
{
fn dispose(&self) {
let owed = {
let mut state = self.inner.state();
if state.disposed {
return;
}
state.disposed = true;
let owed = state.saving.take().map(|waiting| {
waiting.abort();
Inner::values(&state)
});
state.kept.clear();
state.keys.clear();
owed
};
if let (Some(entries), Some(persister)) = (owed, &self.inner.persister) {
saved(persister.as_ref(), &entries);
}
}
}
type Stored = (Value, Value, u64);
#[derive(Serialize, serde::Deserialize)]
struct Document {
version: u64,
#[serde(rename = "writtenAt")]
written_at: u64,
entries: Vec<Stored>,
}
pub struct StoragePersister<K, V> {
storage: Arc<dyn SessionStorage>,
storage_key: String,
version: u64,
max_bytes: usize,
written: Mutex<HashMap<String, (String, u64)>>,
of: PhantomData<fn() -> (K, V)>,
}
impl<K, V> StoragePersister<K, V> {
pub fn new(
storage: Arc<dyn SessionStorage>,
storage_key: impl Into<String>,
version: u64,
max_bytes: usize,
) -> StoragePersister<K, V> {
StoragePersister {
storage,
storage_key: storage_key.into(),
version,
max_bytes,
written: Mutex::new(HashMap::new()),
of: PhantomData,
}
}
}
fn document(raw: Option<&str>, version: u64) -> Option<Document> {
let document: Document = serde_json::from_str(raw?).ok()?;
(document.version == version).then_some(document)
}
fn remembered(written: &Mutex<HashMap<String, (String, u64)>>, document: &Document) {
*written
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner()) = document
.entries
.iter()
.map(|(key, value, at)| (key.to_string(), (value.to_string(), *at)))
.collect();
}
fn entries<K, V>(document: Document) -> HashMap<K, V>
where
K: DeserializeOwned + Eq + Hash,
V: DeserializeOwned,
{
document
.entries
.into_iter()
.filter_map(|(key, value, _)| {
Some((
serde_json::from_value(key).ok()?,
serde_json::from_value(value).ok()?,
))
})
.collect()
}
impl<K, V> CachePersister<K, V> for StoragePersister<K, V>
where
K: Serialize + DeserializeOwned + Eq + Hash + 'static,
V: Serialize + DeserializeOwned + 'static,
{
fn load(&self) -> Option<HashMap<K, V>> {
let document = document(self.storage.get(&self.storage_key).as_deref(), self.version)?;
remembered(&self.written, &document);
Some(entries(document))
}
fn save(
&self,
entries: &HashMap<K, V>,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let now = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map_or(0, |since| {
u64::try_from(since.as_millis()).unwrap_or(u64::MAX)
});
let mut written = self
.written
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
let mut stored: Vec<Stored> = Vec::new();
for (key, value) in entries {
let (Ok(key), Ok(value)) = (serde_json::to_value(key), serde_json::to_value(value))
else {
continue;
};
let as_text = value.to_string();
let at = match written.get(&key.to_string()) {
Some((as_written, at)) if *as_written == as_text => *at,
_ => now,
};
stored.push((key, value, at));
}
let serialized = |entries: &[Stored]| {
serde_json::to_string(&Document {
version: self.version,
written_at: now,
entries: entries.to_vec(),
})
.unwrap_or_default()
};
let mut text = serialized(&stored);
if text.len() > self.max_bytes {
stored.sort_by_key(|(_, _, at)| *at);
while !stored.is_empty() && text.len() > self.max_bytes {
stored.remove(0);
text = serialized(&stored);
}
}
*written = stored
.iter()
.map(|(key, value, at)| (key.to_string(), (value.to_string(), *at)))
.collect();
drop(written);
self.storage.set(&self.storage_key, &text)
}
}