use crate::log_err::LogErr as _;
use std::collections::HashMap;
use std::sync::{Arc, OnceLock, RwLock};
use async_trait::async_trait;
use rustango::jobs::{Job, JobError, JobQueue};
use serde::{Deserialize, Serialize};
use crate::cache_invalidate::PageCacheInvalidator;
#[async_trait]
pub trait TaskSink: Send + Sync + 'static {
async fn dispatch_cache_purge(&self, job: CachePurgeJob) -> Result<(), JobError>;
async fn dispatch_reference_index(&self, job: ReferenceIndexJob) -> Result<(), JobError>;
async fn dispatch_search_index(&self, job: SearchIndexJob) -> Result<(), JobError>;
}
static SINK: OnceLock<Arc<dyn TaskSink>> = OnceLock::new();
pub fn set_sink(sink: Arc<dyn TaskSink>) {
if SINK.set(sink).is_err() {
tracing::error!(target: "rustango_cms", "set_sink: a task sink is already installed; this one is ignored");
}
}
fn sink() -> Option<&'static Arc<dyn TaskSink>> {
SINK.get()
}
pub struct JobQueueSink<Q: JobQueue>(pub Arc<Q>);
#[async_trait]
impl<Q: JobQueue> TaskSink for JobQueueSink<Q> {
async fn dispatch_cache_purge(&self, job: CachePurgeJob) -> Result<(), JobError> {
self.0.dispatch::<CachePurgeJob>(&job).await
}
async fn dispatch_reference_index(&self, job: ReferenceIndexJob) -> Result<(), JobError> {
self.0.dispatch::<ReferenceIndexJob>(&job).await
}
async fn dispatch_search_index(&self, job: SearchIndexJob) -> Result<(), JobError> {
self.0.dispatch::<SearchIndexJob>(&job).await
}
}
pub async fn register_cms_jobs<Q: JobQueue>(queue: &Q) {
queue.register::<CachePurgeJob>().await;
queue.register::<ReferenceIndexJob>().await;
queue.register::<SearchIndexJob>().await;
}
fn invalidator_registry() -> &'static RwLock<HashMap<String, Arc<dyn PageCacheInvalidator>>> {
static REG: OnceLock<RwLock<HashMap<String, Arc<dyn PageCacheInvalidator>>>> = OnceLock::new();
REG.get_or_init(|| RwLock::new(HashMap::new()))
}
pub fn register_invalidator(
tenant_slug: impl Into<String>,
invalidator: Arc<dyn PageCacheInvalidator>,
) {
if let Ok(mut m) = invalidator_registry().write() {
m.insert(tenant_slug.into(), invalidator);
}
}
fn resolve_invalidator(tenant_slug: &str) -> Option<Arc<dyn PageCacheInvalidator>> {
invalidator_registry()
.read()
.ok()
.and_then(|m| m.get(tenant_slug).cloned())
.or_else(|| DEFAULT_INVALIDATOR.get().cloned())
}
static DEFAULT_INVALIDATOR: OnceLock<Arc<dyn PageCacheInvalidator>> = OnceLock::new();
#[must_use]
pub fn default_invalidator() -> Option<Arc<dyn PageCacheInvalidator>> {
DEFAULT_INVALIDATOR.get().cloned()
}
pub fn set_default_invalidator(invalidator: Arc<dyn PageCacheInvalidator>) {
let _ = DEFAULT_INVALIDATOR.set(invalidator);
}
fn pool_registry() -> &'static RwLock<HashMap<String, rustango::sql::Pool>> {
static REG: OnceLock<RwLock<HashMap<String, rustango::sql::Pool>>> = OnceLock::new();
REG.get_or_init(|| RwLock::new(HashMap::new()))
}
pub fn register_pool(tenant_slug: impl Into<String>, pool: rustango::sql::Pool) {
if let Ok(mut m) = pool_registry().write() {
m.insert(tenant_slug.into(), pool);
}
}
fn registered_pool(tenant_slug: &str) -> Option<rustango::sql::Pool> {
pool_registry().read().ok()?.get(tenant_slug).cloned()
}
static REGISTRY: OnceLock<rustango::sql::Pool> = OnceLock::new();
pub fn set_registry(registry: rustango::sql::Pool) {
let _ = REGISTRY.set(registry);
}
pub(crate) async fn resolve_pool(tenant_slug: &str) -> Option<rustango::sql::Pool> {
if let Some(pool) = registered_pool(tenant_slug) {
return Some(pool);
}
let registry = REGISTRY.get()?;
let pool = scoped_pool_for(registry, tenant_slug).await?;
register_pool(tenant_slug, pool.clone());
Some(pool)
}
async fn scoped_pool_for(
registry: &rustango::sql::Pool,
tenant_slug: &str,
) -> Option<rustango::sql::Pool> {
use rustango::core::Column as _;
use rustango::tenancy::{Org, TenantPools};
let org = Org::objects()
.where_(Org::slug.eq(tenant_slug.to_owned()))
.first(registry)
.await
.ok()??;
match registry {
#[cfg(feature = "postgres")]
rustango::sql::Pool::Postgres(pg) => {
TenantPools::<rustango::sql::sqlx::Postgres>::new(pg.clone()).scoped_pool_dyn(&org).await.ok()
}
#[cfg(feature = "sqlite")]
rustango::sql::Pool::Sqlite(sq) => {
TenantPools::<rustango::sql::sqlx::Sqlite>::new(sq.clone()).scoped_pool_dyn(&org).await.ok()
}
#[cfg(feature = "mysql")]
rustango::sql::Pool::Mysql(my) => {
TenantPools::<rustango::sql::sqlx::MySql>::new(my.clone()).scoped_pool_dyn(&org).await.ok()
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CachePurgeJob {
pub tenant_slug: String,
pub urls: Vec<String>,
}
#[async_trait]
impl Job for CachePurgeJob {
const NAME: &'static str = "rcms.cache_purge";
async fn run(&self) -> Result<(), JobError> {
let Some(invalidator) = resolve_invalidator(&self.tenant_slug) else {
return Err(JobError::Fatal(format!(
"cache_purge: no invalidator registered for tenant `{}`",
self.tenant_slug
)));
};
invalidator
.invalidate_urls(&self.tenant_slug, &self.urls)
.await;
Ok(())
}
}
pub async fn purge_urls(
invalidator: Arc<dyn PageCacheInvalidator>,
tenant_slug: String,
urls: Vec<String>,
) {
if urls.is_empty() {
return;
}
let Some(sink) = sink() else {
purge_inline(invalidator.as_ref(), &tenant_slug, &urls).await;
return;
};
register_invalidator(tenant_slug.clone(), invalidator.clone());
let job = CachePurgeJob {
tenant_slug: tenant_slug.clone(),
urls: urls.clone(),
};
if let Err(e) = sink.dispatch_cache_purge(job).await {
tracing::warn!(
target: "rustango_cms::task_queue",
error = %e,
"cache_purge dispatch failed; purging inline so stale entries aren't stranded",
);
purge_inline(invalidator.as_ref(), &tenant_slug, &urls).await;
}
}
async fn purge_inline(invalidator: &dyn PageCacheInvalidator, tenant_slug: &str, urls: &[String]) {
invalidator.invalidate_urls(tenant_slug, urls).await;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OwnedRef {
pub to_kind: String,
pub to_id: i64,
pub field_path: String,
}
impl OwnedRef {
fn from_ref(r: &crate::reference_index::Reference) -> Self {
Self {
to_kind: r.to_kind.to_owned(),
to_id: r.to_id,
field_path: r.field_path.clone(),
}
}
fn to_reference(&self) -> Option<crate::reference_index::Reference> {
let kind = kind_const(&self.to_kind)?;
Some(crate::reference_index::Reference {
to_kind: kind,
to_id: self.to_id,
field_path: self.field_path.clone(),
})
}
}
fn kind_const(s: &str) -> Option<&'static str> {
use crate::reference_index::{KIND_MEDIA, KIND_PAGE, KIND_SNIPPET};
[KIND_PAGE, KIND_SNIPPET, KIND_MEDIA]
.into_iter()
.find(|k| *k == s)
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReferenceIndexJob {
pub tenant_slug: String,
pub page_id: i64,
pub refs: Vec<OwnedRef>,
}
#[async_trait]
impl Job for ReferenceIndexJob {
const NAME: &'static str = "rcms.reference_index";
async fn run(&self) -> Result<(), JobError> {
let Some(pool) = resolve_pool(&self.tenant_slug).await else {
return Err(JobError::Fatal(format!(
"reference_index: no pool registered for tenant `{}`",
self.tenant_slug
)));
};
let refs = self
.refs
.iter()
.filter_map(OwnedRef::to_reference)
.collect();
crate::reference_index::reindex_source(
&pool,
crate::reference_index::KIND_PAGE,
self.page_id,
refs,
)
.await
.map_err(|e| JobError::Retryable(format!("reference_index: {e}")))
}
}
pub async fn reindex_page(
pool: &rustango::sql::Pool,
tenant_slug: &str,
page_id: i64,
refs: Vec<crate::reference_index::Reference>,
) {
let Some(sink) = sink() else {
reindex_inline(pool, page_id, refs).await;
return;
};
register_pool(tenant_slug.to_owned(), pool.clone());
let job = ReferenceIndexJob {
tenant_slug: tenant_slug.to_owned(),
page_id,
refs: refs.iter().map(OwnedRef::from_ref).collect(),
};
if let Err(e) = sink.dispatch_reference_index(job).await {
tracing::warn!(
target: "rustango_cms::task_queue",
error = %e,
"reference_index dispatch failed; reindexing inline",
);
reindex_inline(pool, page_id, refs).await;
}
}
async fn reindex_inline(
pool: &rustango::sql::Pool,
page_id: i64,
refs: Vec<crate::reference_index::Reference>,
) {
if let Err(e) = crate::reference_index::reindex_source(
pool,
crate::reference_index::KIND_PAGE,
page_id,
refs,
)
.await
{
tracing::warn!(
target: "rustango_cms::task_queue",
page_id,
error = %e,
"inline reference reindex failed",
);
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum SearchIndexAction {
Index(crate::search::SearchDoc),
Delete(i64),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SearchIndexJob {
pub tenant_slug: String,
pub action: SearchIndexAction,
}
#[async_trait]
impl Job for SearchIndexJob {
const NAME: &'static str = "rcms.search_index";
async fn run(&self) -> Result<(), JobError> {
let Some(backend) = crate::search::backend() else {
return Ok(());
};
match &self.action {
SearchIndexAction::Index(doc) => backend.index(&self.tenant_slug, doc).await,
SearchIndexAction::Delete(page_id) => backend.delete(&self.tenant_slug, *page_id).await,
}
Ok(())
}
}
pub async fn sync_page_search(tenant_slug: &str, page: &crate::page::Page) {
if crate::search::backend().is_none() {
return;
}
let Some(page_id) = page.id.get().copied() else {
return;
};
let is_public = page.status == crate::page::PageStatus::Published.as_str()
|| page.status == crate::page::PageStatus::Archived.as_str();
let action = if is_public {
SearchIndexAction::Index(crate::search::SearchDoc {
page_id,
title: page.title.clone(),
seo_title: page.seo_title.clone(),
seo_description: page.seo_description.clone(),
url_path: page.url_path.clone(),
status: page.status.clone(),
})
} else {
SearchIndexAction::Delete(page_id)
};
let job = SearchIndexJob {
tenant_slug: tenant_slug.to_owned(),
action,
};
match sink() {
Some(s) => {
if let Err(e) = s.dispatch_search_index(job.clone()).await {
tracing::warn!(
target: "rustango_cms::task_queue",
error = %e,
"search_index dispatch failed; running inline",
);
job.run().await.log_warn("search index job failed; the index may be stale");
}
}
None => {
job.run().await.log_warn("search index job failed; the index may be stale");
}
}
}
pub async fn remove_page_search(tenant_slug: &str, page_id: i64) {
if crate::search::backend().is_none() {
return;
}
let job = SearchIndexJob {
tenant_slug: tenant_slug.to_owned(),
action: SearchIndexAction::Delete(page_id),
};
match sink() {
Some(s) => {
if s.dispatch_search_index(job.clone()).await.is_err() {
job.run().await.log_warn("search index job failed; the index may be stale");
}
}
None => {
job.run().await.log_warn("search index job failed; the index may be stale");
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::atomic::{AtomicUsize, Ordering};
struct Counting(Arc<AtomicUsize>);
#[async_trait]
impl PageCacheInvalidator for Counting {
async fn invalidate_url(&self, _tenant_slug: &str, _url_path: &str) {
self.0.fetch_add(1, Ordering::SeqCst);
}
}
#[test]
fn job_round_trips_and_has_stable_name() {
let job = CachePurgeJob {
tenant_slug: "acme".to_owned(),
urls: vec!["/a".to_owned(), "/b".to_owned()],
};
let json = serde_json::to_string(&job).unwrap();
let back: CachePurgeJob = serde_json::from_str(&json).unwrap();
assert_eq!(back.tenant_slug, "acme");
assert_eq!(back.urls, vec!["/a", "/b"]);
assert_eq!(CachePurgeJob::NAME, "rcms.cache_purge");
}
#[tokio::test]
async fn run_purges_when_invalidator_registered() {
let n = Arc::new(AtomicUsize::new(0));
register_invalidator("acme-run", Arc::new(Counting(n.clone())));
let job = CachePurgeJob {
tenant_slug: "acme-run".to_owned(),
urls: vec!["/x".to_owned(), "/y".to_owned(), "/z".to_owned()],
};
assert!(job.run().await.is_ok());
assert_eq!(n.load(Ordering::SeqCst), 3);
}
#[tokio::test]
async fn run_is_fatal_without_registration() {
let job = CachePurgeJob {
tenant_slug: "never-registered-tenant".to_owned(),
urls: vec!["/x".to_owned()],
};
match job.run().await {
Err(JobError::Fatal(_)) => {}
other => panic!("expected Fatal, got {other:?}"),
}
}
#[tokio::test]
async fn purge_urls_runs_inline_when_no_sink() {
let n = Arc::new(AtomicUsize::new(0));
let inv: Arc<dyn PageCacheInvalidator> = Arc::new(Counting(n.clone()));
purge_urls(
inv,
"acme-inline".to_owned(),
vec!["/a".to_owned(), "/b".to_owned()],
)
.await;
assert_eq!(n.load(Ordering::SeqCst), 2);
let inv2: Arc<dyn PageCacheInvalidator> = Arc::new(Counting(n.clone()));
purge_urls(inv2, "acme-inline".to_owned(), vec![]).await;
assert_eq!(n.load(Ordering::SeqCst), 2);
}
#[test]
fn owned_ref_round_trips_known_kind_skips_unknown() {
use crate::reference_index::{Reference, KIND_MEDIA};
let r = Reference {
to_kind: KIND_MEDIA,
to_id: 7,
field_path: "body".to_owned(),
};
let owned = OwnedRef::from_ref(&r);
assert_eq!(owned.to_kind, "cms_media");
let back = owned.to_reference().expect("known kind");
assert_eq!(back.to_kind, KIND_MEDIA);
assert_eq!(back.to_id, 7);
let bogus = OwnedRef {
to_kind: "cms_widget".to_owned(),
to_id: 1,
field_path: "x".to_owned(),
};
assert!(bogus.to_reference().is_none());
}
#[test]
fn reference_index_job_round_trips_and_named() {
let job = ReferenceIndexJob {
tenant_slug: "acme".to_owned(),
page_id: 9,
refs: vec![OwnedRef {
to_kind: "cms_media".to_owned(),
to_id: 3,
field_path: "hero".to_owned(),
}],
};
let json = serde_json::to_string(&job).unwrap();
let back: ReferenceIndexJob = serde_json::from_str(&json).unwrap();
assert_eq!(back.page_id, 9);
assert_eq!(back.refs.len(), 1);
assert_eq!(ReferenceIndexJob::NAME, "rcms.reference_index");
}
#[tokio::test]
async fn reference_index_job_is_fatal_without_pool() {
let job = ReferenceIndexJob {
tenant_slug: "tenant-with-no-registered-pool".to_owned(),
page_id: 1,
refs: vec![],
};
match job.run().await {
Err(JobError::Fatal(_)) => {}
other => panic!("expected Fatal, got {other:?}"),
}
}
#[test]
fn search_index_job_round_trips_both_actions() {
let idx = SearchIndexJob {
tenant_slug: "acme".to_owned(),
action: SearchIndexAction::Index(crate::search::SearchDoc {
page_id: 5,
title: "Hi".to_owned(),
seo_title: String::new(),
seo_description: String::new(),
url_path: "/hi".to_owned(),
status: "published".to_owned(),
}),
};
let back: SearchIndexJob =
serde_json::from_str(&serde_json::to_string(&idx).unwrap()).unwrap();
assert!(matches!(back.action, SearchIndexAction::Index(d) if d.page_id == 5));
let del = SearchIndexJob {
tenant_slug: "acme".to_owned(),
action: SearchIndexAction::Delete(9),
};
let back2: SearchIndexJob =
serde_json::from_str(&serde_json::to_string(&del).unwrap()).unwrap();
assert!(matches!(back2.action, SearchIndexAction::Delete(9)));
assert_eq!(SearchIndexJob::NAME, "rcms.search_index");
}
#[tokio::test]
async fn search_index_job_is_noop_without_backend() {
let job = SearchIndexJob {
tenant_slug: "acme".to_owned(),
action: SearchIndexAction::Delete(1),
};
assert!(job.run().await.is_ok());
}
}