use std::sync::Arc;
use async_trait::async_trait;
use rustango::cache::BoxedCache;
use rustango::cache_page::{CachePageLayer, PageKey};
use rustango::tenancy::TenantSlug;
#[async_trait]
pub trait PageCacheInvalidator: Send + Sync + 'static {
async fn invalidate_url(&self, tenant: &TenantSlug, url_path: &str);
async fn invalidate_subtree(&self, tenant: &TenantSlug, url_path: &str) {
self.invalidate_url(tenant, url_path).await;
}
async fn invalidate_urls(&self, tenant: &TenantSlug, url_paths: &[String]) {
for url in url_paths {
self.invalidate_url(tenant, url).await;
}
}
}
#[async_trait]
pub trait AccessTokenSource: Send + Sync + 'static {
async fn token(&self) -> Option<String>;
}
#[derive(Debug, Clone)]
pub struct StaticToken(pub String);
#[async_trait]
impl AccessTokenSource for StaticToken {
async fn token(&self) -> Option<String> {
Some(self.0.clone())
}
}
#[derive(Default, Debug, Clone, Copy)]
pub struct Noop;
#[async_trait]
impl PageCacheInvalidator for Noop {
async fn invalidate_url(&self, _tenant: &TenantSlug, _url_path: &str) {}
}
#[must_use]
pub fn noop() -> Arc<dyn PageCacheInvalidator> {
Arc::new(Noop)
}
pub fn invalidate_urls_on_commit(
invalidator: Arc<dyn PageCacheInvalidator>,
tenant: TenantSlug,
url_paths: Vec<String>,
) {
if url_paths.is_empty() {
return;
}
rustango::sql::on_commit(move || {
rustango::__private_runtime::tokio::spawn(async move {
crate::task_queue::purge_urls(invalidator, tenant, url_paths).await;
});
});
}
pub struct BoxedCacheInvalidator {
layer: CachePageLayer,
hosts_by_tenant: std::collections::HashMap<String, Vec<String>>,
default_hosts: Vec<String>,
vary_values: Vec<(String, String)>,
}
impl BoxedCacheInvalidator {
#[must_use]
pub fn new(cache: BoxedCache, key_prefix: impl Into<String>) -> Self {
Self {
layer: CachePageLayer::new(cache).key_prefix(key_prefix),
hosts_by_tenant: std::collections::HashMap::new(),
default_hosts: Vec::new(),
vary_values: Vec::new(),
}
}
#[must_use]
pub fn with_tenant_hosts(
mut self,
tenant_slug: impl Into<String>,
hosts: impl IntoIterator<Item = String>,
) -> Self {
self.hosts_by_tenant
.insert(tenant_slug.into(), hosts.into_iter().collect());
self
}
#[must_use]
pub fn with_default_hosts(mut self, hosts: impl IntoIterator<Item = String>) -> Self {
self.default_hosts = hosts.into_iter().collect();
self
}
#[must_use]
pub fn with_vary_values(mut self, pairs: impl IntoIterator<Item = (String, String)>) -> Self {
self.vary_values = pairs.into_iter().collect();
let names: Vec<String> = self.vary_values.iter().map(|(n, _)| n.clone()).collect();
self.layer = self.layer.vary_on(&names);
self
}
fn pages_for(&self, tenant: &TenantSlug, url_path: &str) -> Vec<PageKey> {
self.hosts_by_tenant
.get(&tenant.slug)
.unwrap_or(&self.default_hosts)
.iter()
.map(|host| {
let mut page = PageKey::new(url_path, host.as_str()).tenant(tenant);
for (name, value) in &self.vary_values {
page = page.vary(name, value.as_str());
}
page
})
.collect()
}
}
#[async_trait]
impl PageCacheInvalidator for BoxedCacheInvalidator {
async fn invalidate_url(&self, tenant: &TenantSlug, url_path: &str) {
let pages = self.pages_for(tenant, url_path);
if pages.is_empty() {
tracing::debug!(
target: "rustango_cms::cache_invalidate",
tenant = %tenant.slug,
"no hosts configured — skipping cache invalidation"
);
return;
}
match self.layer.invalidate(&pages).await {
Ok(()) => tracing::debug!(
target: "rustango_cms::cache_invalidate",
tenant = %tenant.slug,
path = %url_path,
"purged"
),
Err(e) => tracing::warn!(
target: "rustango_cms::cache_invalidate",
tenant = %tenant.slug,
path = %url_path,
error = %e,
"cache purge failed (continuing — TTL will catch up)"
),
}
}
}
#[cfg(test)]
mod on_commit_tests {
use super::*;
#[test]
fn empty_url_list_is_a_noop_outside_atomic() {
invalidate_urls_on_commit(noop(), TenantSlug::new(1, "acme"), vec![]);
}
#[test]
#[should_panic(expected = "on_commit")]
fn non_empty_outside_atomic_panics() {
invalidate_urls_on_commit(noop(), TenantSlug::new(1, "acme"), vec!["/about".to_owned()]);
}
}
#[cfg(all(test, feature = "sqlite"))]
mod on_commit_db_tests {
use super::*;
use rustango::sql::Pool;
use std::sync::Mutex;
struct Recorder(Arc<Mutex<Vec<String>>>);
#[async_trait]
impl PageCacheInvalidator for Recorder {
async fn invalidate_url(&self, _tenant: &rustango::tenancy::TenantSlug, url_path: &str) {
self.0
.lock()
.expect("recorder mutex")
.push(url_path.to_owned());
}
}
async fn mem_pool() -> Pool {
Pool::connect("sqlite::memory:")
.await
.expect("sqlite in-memory pool")
}
async fn wait_until(urls: &Arc<Mutex<Vec<String>>>, n: usize) -> Vec<String> {
for _ in 0..5000 {
{
let g = urls.lock().expect("recorder mutex");
if g.len() >= n {
return g.clone();
}
}
tokio::task::yield_now().await;
}
urls.lock().expect("recorder mutex").clone()
}
#[tokio::test]
async fn commit_fires_the_purge_in_order() {
let pool = mem_pool().await;
let urls = Arc::new(Mutex::new(Vec::new()));
let inv: Arc<dyn PageCacheInvalidator> = Arc::new(Recorder(urls.clone()));
rustango::atomic!(&pool, |_tx| {
invalidate_urls_on_commit(
inv.clone(),
TenantSlug::new(1, "acme"),
vec!["/about".to_owned(), "/news".to_owned()],
);
assert_eq!(rustango::sql::on_commit_pending(), 1, "one callback queued");
Ok::<(), rustango::sql::ExecError>(())
})
.await
.expect("atomic commit");
assert_eq!(
wait_until(&urls, 2).await,
vec!["/about".to_owned(), "/news".to_owned()]
);
}
#[tokio::test]
async fn rollback_drops_the_purge() {
let pool = mem_pool().await;
let urls = Arc::new(Mutex::new(Vec::new()));
let inv: Arc<dyn PageCacheInvalidator> = Arc::new(Recorder(urls.clone()));
let res = rustango::atomic!(&pool, |_tx| {
invalidate_urls_on_commit(inv.clone(), TenantSlug::new(1, "acme"), vec!["/about".to_owned()]);
assert_eq!(
rustango::sql::on_commit_pending(),
1,
"callback queued pre-rollback"
);
Err::<(), rustango::sql::ExecError>(rustango::sql::ExecError::EmptyReturning)
})
.await;
assert!(res.is_err(), "atomic should roll back");
for _ in 0..50 {
tokio::task::yield_now().await;
}
assert!(
urls.lock().expect("recorder mutex").is_empty(),
"rollback must not purge"
);
}
}