use super::browse::{self, BrowseNamespace, WHOLE, invalidate_engines};
use super::gather::{GatherNamespace, ReferencedBy};
use super::match_::{MatchNamespace, ResourceSearch};
use crate::bus::held_to;
use crate::cache::{Cache, CacheKey, CacheValue};
use crate::client::Links;
use crate::locked;
use crate::refresh::{CacheQuery, CacheRefresh, Reach, RefreshTrigger, RefreshWhen};
use crate::transport::{ConnectionState, Frame, FrameRefusal, Lagged};
use crate::types::{Annotation, AnnotationId, MatchResourcesResponse, ResourceId};
use serde::Deserialize;
use serde_json::Value;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::time::Duration;
use tokio::sync::watch;
use tokio::task::{AbortHandle, JoinSet};
type Owed = Box<dyn FnOnce() + Send>;
struct Window {
owed: Option<Owed>,
closing: AbortHandle,
}
struct Windows {
lasting: Duration,
open: Mutex<Option<HashMap<String, Window>>>,
}
impl Windows {
fn run(self: &Arc<Self>, key: String, refetch: Owed) {
let mut open = locked(&self.open);
let Some(windows) = open.as_mut() else {
return;
};
if let Some(window) = windows.get_mut(&key) {
window.owed = Some(refetch);
return;
}
let these = Arc::downgrade(self);
let lasting = self.lasting;
let of = key.clone();
let closing = tokio::spawn(async move {
tokio::time::sleep(lasting).await;
let Some(these) = these.upgrade() else {
return;
};
let owed = locked(&these.open)
.as_mut()
.and_then(|windows| windows.remove(&of))
.and_then(|window| window.owed);
if let Some(owed) = owed {
these.run(of, owed);
}
})
.abort_handle();
windows.insert(
key,
Window {
owed: None,
closing,
},
);
drop(open);
refetch();
}
fn dispose(&self) {
if let Some(windows) = locked(&self.open).take() {
for window in windows.into_values() {
window.closing.abort();
}
}
}
}
#[derive(Default)]
pub(super) struct Subject {
pub(super) when: Option<RefreshWhen>,
pub(super) resource: Option<ResourceId>,
pub(super) annotation: Option<AnnotationId>,
pub(super) written: Option<Annotation>,
}
struct Unreadable;
fn member_at<'a>(event: &'a Value, way: Option<&[&str]>) -> Result<Option<&'a Value>, Unreadable> {
let Some(way) = way else {
return Ok(None);
};
let mut member = event;
for name in way {
member = match member {
Value::Null => return Ok(None),
Value::Object(members) => match members.get(*name) {
Some(within) => within,
None => return Ok(None),
},
_ => return Err(Unreadable),
};
}
Ok(match member {
Value::Null => None,
present => Some(present),
})
}
fn named<'a, T: Deserialize<'a>>(
event: &'a Value,
way: Option<&[&str]>,
) -> Result<Option<T>, Unreadable> {
match member_at(event, way)? {
None => Ok(None),
Some(member) => T::deserialize(member).map(Some).map_err(|_| Unreadable),
}
}
fn row(trigger: RefreshTrigger, when: Option<RefreshWhen>) -> &'static CacheRefresh {
match trigger.rows().iter().find(|row| row.when == when) {
Some(row) => row,
None => panic!("the refresh table has no row for {trigger:?} when {when:?}"),
}
}
fn subject(
trigger: RefreshTrigger,
channel: &str,
frame: Result<Result<Frame, FrameRefusal>, Lagged>,
) -> Result<Subject, Unreadable> {
let Ok(Ok(frame)) = frame else {
return Err(Unreadable);
};
let event = held_to(channel, frame.payload).map_err(|_| Unreadable)?;
let enriched = trigger
.rows()
.iter()
.find(|row| row.when == Some(RefreshWhen::Enriched));
let when = match enriched {
None => None,
Some(enriched) => match member_at(&event, enriched.carries)? {
Some(_) => Some(RefreshWhen::Enriched),
None => Some(RefreshWhen::Unenriched),
},
};
let row = row(trigger, when);
Ok(Subject {
when,
resource: named(&event, row.names.resource)?,
annotation: named(&event, row.names.annotation)?,
written: named(&event, row.carries)?,
})
}
pub(crate) struct Refresher {
browse: Arc<browse::Live>,
referenced_by: Cache<ResourceId, Vec<ReferencedBy>>,
searches: Cache<ResourceSearch, MatchResourcesResponse>,
windows: Arc<Windows>,
listening: Mutex<JoinSet<()>>,
}
impl Refresher {
pub(crate) fn new(
links: &Links,
browse: &BrowseNamespace,
gather: &GatherNamespace,
match_: &MatchNamespace,
) -> Arc<Refresher> {
let refresher = Arc::new(Refresher {
browse: browse.live.clone(),
referenced_by: gather.referenced_by.clone(),
searches: match_.searches.clone(),
windows: Arc::new(Windows {
lasting: links.timing.invalidation_window,
open: Mutex::new(Some(HashMap::new())),
}),
listening: Mutex::new(JoinSet::new()),
});
refresher.listen(links);
refresher
}
fn listen(self: &Arc<Self>, links: &Links) {
self.on_reopening(links.transport.state());
for trigger in RefreshTrigger::ALL {
if let Some(channel) = trigger.channel() {
self.on(links, *trigger, channel);
}
}
}
fn on(self: &Arc<Self>, links: &Links, trigger: RefreshTrigger, channel: &'static str) {
let mut frames = links.own.frames(channel);
let refresher = Arc::downgrade(self);
locked(&self.listening).spawn(async move {
while let Some(frame) = frames.next().await {
let Some(refresher) = refresher.upgrade() else {
return;
};
match subject(trigger, channel, frame) {
Ok(subject) => refresher.refresh(trigger, &subject),
Err(Unreadable) => {
refresher.refresh(RefreshTrigger::Unreadable, &Subject::default());
}
}
}
});
}
fn on_reopening(self: &Arc<Self>, mut state: watch::Receiver<ConnectionState>) {
let refresher = Arc::downgrade(self);
locked(&self.listening).spawn(async move {
let (mut opened, mut left) = (false, false);
loop {
if *state.borrow_and_update() == ConnectionState::Open {
if left && let Some(refresher) = refresher.upgrade() {
refresher.refresh(RefreshTrigger::Reopened, &Subject::default());
}
opened = true;
left = false;
} else {
left = opened;
}
if state.changed().await.is_err() {
return;
}
}
});
}
fn refresh(&self, trigger: RefreshTrigger, subject: &Subject) {
let row = row(trigger, subject.when);
for query in row.writes {
self.browse.write(*query, subject);
}
for query in row.removes {
self.browse.remove(*query, subject);
}
for query in row.refetches {
self.refetch(*query, subject, row.reach);
}
}
fn again<K, V>(&self, cache: &Cache<K, V>, key: K, window: String)
where
K: CacheKey,
V: CacheValue,
{
if cache.known(&key) {
let cache = cache.clone();
self.windows
.run(window, Box::new(move || cache.invalidate(&key)));
}
}
fn all_again<K, V>(&self, cache: &Cache<K, V>, window: &str)
where
K: CacheKey,
V: CacheValue,
{
let cache = cache.clone();
self.windows
.run(window.to_owned(), Box::new(move || cache.invalidate_all()));
}
fn refetch(&self, query: CacheQuery, subject: &Subject, reach: Reach) {
let browse = &self.browse;
let reached = |held: Vec<ResourceId>| match reach {
Reach::Held => held,
Reach::Subject => subject.resource.iter().cloned().collect(),
};
match query {
CacheQuery::Resource => {
for id in reached(browse.resource.keys()) {
let window = format!("resource/{id}");
self.again(&browse.resource, id, window);
}
}
CacheQuery::Annotations => {
for id in reached(browse.annotations.keys()) {
let window = format!("annotations/{id}");
self.again(&browse.annotations, id, window);
}
}
CacheQuery::Events => {
for id in reached(browse.events.keys()) {
let window = format!("events/{id}");
self.again(&browse.events, id, window);
}
}
CacheQuery::ReferencedBy => {
for id in reached(self.referenced_by.keys()) {
let window = format!("referenced-by/{id}");
self.again(&self.referenced_by, id, window);
}
}
CacheQuery::Annotation => {
let annotations = match (reach, &subject.annotation) {
(Reach::Held, _) => browse.annotation.keys(),
(Reach::Subject, Some(annotation)) => vec![annotation.clone()],
(Reach::Subject, None) => locked(&browse.annotation_of)
.iter()
.filter(|(_, of)| Some(*of) == subject.resource.as_ref())
.map(|(annotation, _)| annotation.clone())
.collect(),
};
for id in annotations {
let window = format!("annotation/{id}");
self.again(&browse.annotation, id, window);
}
}
CacheQuery::Resources => self.all_again(&browse.lists, "resource-lists"),
CacheQuery::MatchedResources => self.all_again(&self.searches, "matched-resources"),
CacheQuery::EntityTypes => {
self.again(
&browse.entity_types,
WHOLE.to_owned(),
"entity-types".to_owned(),
);
}
CacheQuery::TagSchemas => {
self.again(
&browse.tag_schemas,
WHOLE.to_owned(),
"tag-schemas".to_owned(),
);
}
CacheQuery::Engines => {
if browse.engines.known(&WHOLE.to_owned()) {
let (engines, limits) = (browse.engines.clone(), browse.limits.clone());
self.windows.run(
"engines".to_owned(),
Box::new(move || invalidate_engines(&engines, &limits)),
);
}
}
}
}
pub(crate) fn dispose(&self) {
locked(&self.listening).abort_all();
self.windows.dispose();
}
}
impl Drop for Refresher {
fn drop(&mut self) {
self.dispose();
}
}