use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, RwLock};
use std::time::{Duration, Instant, SystemTime};
use tera::Tera;
pub const DEFAULT_DIR: &str = "templates_tenants";
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Reload {
Always,
Every(Duration),
Never,
}
impl Default for Reload {
fn default() -> Self {
Self::Every(Duration::from_secs(5))
}
}
static TICK: AtomicU64 = AtomicU64::new(0);
fn tick() -> u64 {
TICK.fetch_add(1, Ordering::Relaxed)
}
struct Entry {
tera: Arc<Tera>,
fingerprint: u64,
checked: Instant,
used: AtomicU64,
}
const OWNER_FILE: &str = ".rcms-owner";
const ORPHANED_DIR: &str = ".orphaned";
#[derive(Debug, PartialEq, Eq)]
pub enum Claim {
NoOverrides,
Owned,
Adopted,
MovedAside { previous_owner: String, to: PathBuf },
}
pub struct TenantTemplates {
base: Arc<Tera>,
root: PathBuf,
global_dir: Option<PathBuf>,
reload: Reload,
capacity: usize,
cache: RwLock<HashMap<String, Entry>>,
}
impl TenantTemplates {
#[must_use]
pub fn new(base: Arc<Tera>, root: impl Into<PathBuf>) -> Self {
Self {
base,
root: root.into(),
global_dir: None,
reload: Reload::default(),
capacity: 64,
cache: RwLock::new(HashMap::new()),
}
}
#[must_use]
pub fn with_global_dir(mut self, dir: impl Into<PathBuf>) -> Self {
self.global_dir = Some(dir.into());
self
}
#[must_use]
pub fn with_reload(mut self, reload: Reload) -> Self {
self.reload = reload;
self
}
#[must_use]
pub fn with_capacity(mut self, capacity: usize) -> Self {
self.capacity = capacity.max(1);
self
}
#[must_use]
pub fn cached(&self, slug: &str) -> Option<Arc<Tera>> {
let cache = self.cache.read().ok()?;
let e = cache.get(slug)?;
if self.due(e) {
return None;
}
e.used.store(tick(), Ordering::Relaxed);
Some(Arc::clone(&e.tera))
}
#[must_use]
pub fn for_tenant(&self, slug: &str) -> Arc<Tera> {
let Some(dir) = self.tenant_dir(slug) else {
return Arc::clone(&self.base);
};
if let Ok(cache) = self.cache.read() {
if let Some(e) = cache.get(slug) {
if !self.due(e) {
e.used.store(tick(), Ordering::Relaxed);
return Arc::clone(&e.tera);
}
}
}
let fingerprint = fingerprint(&dir);
if let Ok(mut cache) = self.cache.write() {
if let Some(e) = cache.get_mut(slug) {
if e.fingerprint == fingerprint {
e.checked = Instant::now();
e.used.store(tick(), Ordering::Relaxed);
return Arc::clone(&e.tera);
}
}
}
let tera = Arc::new(self.build(&dir));
if let Ok(mut cache) = self.cache.write() {
if cache.len() >= self.capacity && !cache.contains_key(slug) {
Self::evict_lru(&mut cache);
}
cache.insert(
slug.to_owned(),
Entry {
tera: Arc::clone(&tera),
fingerprint,
checked: Instant::now(),
used: AtomicU64::new(tick()),
},
);
}
tera
}
fn due(&self, e: &Entry) -> bool {
match self.reload {
Reload::Always => true,
Reload::Never => false,
Reload::Every(d) => e.checked.elapsed() >= d,
}
}
fn evict_lru(cache: &mut HashMap<String, Entry>) {
if let Some(oldest) = cache
.iter()
.min_by_key(|(_, e)| e.used.load(Ordering::Relaxed))
.map(|(k, _)| k.clone())
{
cache.remove(&oldest);
}
}
fn tenant_dir(&self, slug: &str) -> Option<PathBuf> {
if slug.is_empty()
|| slug.starts_with('.')
|| slug.contains('/')
|| slug.contains('\\')
{
return None;
}
let dir = self.root.join(slug);
dir.is_dir().then_some(dir)
}
pub fn claim(&self, slug: &str, owner: &str) -> std::io::Result<Claim> {
let Some(dir) = self.tenant_dir(slug) else {
return Ok(Claim::NoOverrides);
};
let marker = dir.join(OWNER_FILE);
match std::fs::read_to_string(&marker) {
Ok(found) if found.trim() == owner => Ok(Claim::Owned),
Ok(found) => {
let aside_root = self.root.join(ORPHANED_DIR);
std::fs::create_dir_all(&aside_root)?;
let stamp = SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.map_or(0, |d| d.as_secs());
let aside = aside_root.join(format!("{slug}-{stamp}"));
std::fs::rename(&dir, &aside)?;
if let Ok(mut cache) = self.cache.write() {
cache.remove(slug);
}
Ok(Claim::MovedAside { previous_owner: found.trim().to_owned(), to: aside })
}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
std::fs::write(&marker, owner)?;
Ok(Claim::Adopted)
}
Err(e) => Err(e),
}
}
fn build(&self, dir: &Path) -> Tera {
let mut tera = (*self.base).clone();
let mut overrides: Vec<(String, String)> = Vec::new();
collect(dir, dir, &mut overrides);
overrides.sort_by(|a, b| a.0.cmp(&b.0));
for (name, body) in overrides {
if let Err(e) = tera.add_raw_template(&name, &body) {
tracing::warn!(
target: "rustango_cms::tenant_templates",
template = %name, error = %e,
"tenant template failed to parse; falling back to the global one",
);
}
}
if let Err(e) = tera.build_inheritance_chains() {
tracing::error!(
target: "rustango_cms::tenant_templates",
error = %e,
"tenant template inheritance is broken; serving the global set",
);
return (*self.base).clone();
}
tera
}
}
fn collect(root: &Path, dir: &Path, out: &mut Vec<(String, String)>) {
let Ok(entries) = std::fs::read_dir(dir) else {
return;
};
for entry in entries.flatten() {
let path = entry.path();
if !contained(root, &path) {
continue;
}
if path.is_dir() {
collect(root, &path, out);
continue;
}
if path.extension().and_then(|e| e.to_str()) != Some("html") {
continue;
}
let Ok(rel) = path.strip_prefix(root) else {
continue;
};
let name = rel
.components()
.filter_map(|c| c.as_os_str().to_str())
.collect::<Vec<_>>()
.join("/");
if let Ok(body) = std::fs::read_to_string(&path) {
out.push((name, body));
}
}
}
fn fingerprint(dir: &Path) -> u64 {
let mut files: Vec<(String, u64, u64)> = Vec::new();
let mut names: Vec<(String, String)> = Vec::new();
collect_meta(dir, dir, &mut names);
for (name, _) in &names {
let path = dir.join(name);
let (len, mtime) = std::fs::metadata(&path)
.map(|m| {
(
m.len(),
m.modified()
.ok()
.and_then(|t| t.duration_since(SystemTime::UNIX_EPOCH).ok())
.map_or(0, |d| d.as_nanos() as u64),
)
})
.unwrap_or((0, 0));
files.push((name.clone(), len, mtime));
}
files.sort();
let mut h: u64 = 0xcbf2_9ce4_8422_2325;
let mut eat = |bytes: &[u8]| {
for b in bytes {
h ^= u64::from(*b);
h = h.wrapping_mul(0x0000_0100_0000_01b3);
}
};
for (name, len, mtime) in &files {
eat(name.as_bytes());
eat(&len.to_le_bytes());
eat(&mtime.to_le_bytes());
}
h
}
fn collect_meta(root: &Path, dir: &Path, out: &mut Vec<(String, String)>) {
let Ok(entries) = std::fs::read_dir(dir) else {
return;
};
for entry in entries.flatten() {
let path = entry.path();
if !contained(root, &path) {
continue;
}
if path.is_dir() {
collect_meta(root, &path, out);
continue;
}
if path.extension().and_then(|e| e.to_str()) != Some("html") {
continue;
}
if let Ok(rel) = path.strip_prefix(root) {
let name = rel
.components()
.filter_map(|c| c.as_os_str().to_str())
.collect::<Vec<_>>()
.join("/");
out.push((name, String::new()));
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "lowercase")]
pub enum Source {
Override,
Global,
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct TemplateEntry {
pub name: String,
pub source: Source,
pub bytes: u64,
}
#[derive(Debug)]
pub enum EditError {
BadName(String),
Invalid(String),
NotConfigured,
Io(std::io::Error),
}
impl std::fmt::Display for EditError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::BadName(n) => write!(f, "`{n}` is not a valid template name"),
Self::Invalid(e) => write!(f, "{e}"),
Self::NotConfigured => write!(f, "per-tenant templates are not configured"),
Self::Io(e) => write!(f, "{e}"),
}
}
}
pub fn safe_name(name: &str) -> Result<String, EditError> {
let n = name.trim().trim_start_matches('/');
let bad = n.is_empty()
|| !n.ends_with(".html")
|| n.contains('\\')
|| n.starts_with('.')
|| n.split('/').any(|seg| seg.is_empty() || seg == "." || seg == "..")
|| std::path::Path::new(n).is_absolute();
if bad {
return Err(EditError::BadName(name.to_owned()));
}
Ok(n.to_owned())
}
impl TenantTemplates {
#[must_use]
pub fn dir_for(&self, slug: &str) -> Option<PathBuf> {
if slug.is_empty() || slug.contains('/') || slug.contains('\\') || slug.starts_with('.') {
return None;
}
Some(self.root.join(slug))
}
#[must_use]
pub fn list_for(&self, slug: &str) -> Vec<TemplateEntry> {
let mut seen: HashMap<String, TemplateEntry> = HashMap::new();
if let Some(g) = &self.global_dir {
let mut names = Vec::new();
collect_meta(g, g, &mut names);
for (name, _) in names {
let bytes = std::fs::metadata(g.join(&name)).map(|m| m.len()).unwrap_or(0);
seen.insert(name.clone(), TemplateEntry { name, source: Source::Global, bytes });
}
}
if let Some(dir) = self.dir_for(slug).filter(|d| d.is_dir()) {
let mut names = Vec::new();
collect_meta(&dir, &dir, &mut names);
for (name, _) in names {
let bytes = std::fs::metadata(dir.join(&name)).map(|m| m.len()).unwrap_or(0);
seen.insert(name.clone(), TemplateEntry { name, source: Source::Override, bytes });
}
}
let mut out: Vec<TemplateEntry> = seen.into_values().collect();
out.sort_by(|a, b| a.name.cmp(&b.name));
out
}
#[must_use]
pub fn read_override(&self, slug: &str, name: &str) -> Option<String> {
let name = safe_name(name).ok()?;
let dir = self.dir_for(slug)?;
let path = dir.join(name);
if !contained(&dir, &path) {
return None;
}
std::fs::read_to_string(path).ok()
}
#[must_use]
pub fn read_global(&self, name: &str) -> Option<String> {
let name = safe_name(name).ok()?;
std::fs::read_to_string(self.global_dir.as_ref()?.join(name)).ok()
}
pub fn write_override(&self, slug: &str, name: &str, body: &str) -> Result<(), EditError> {
let name = safe_name(name)?;
let dir = self.dir_for(slug).ok_or(EditError::NotConfigured)?;
self.validate(slug, &name, body)?;
let path = dir.join(&name);
std::fs::create_dir_all(&dir).map_err(EditError::Io)?;
if !contained(&dir, &path) {
return Err(EditError::BadName(name));
}
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent).map_err(EditError::Io)?;
}
std::fs::write(&path, body).map_err(EditError::Io)?;
Ok(())
}
pub fn validate(&self, slug: &str, name: &str, body: &str) -> Result<(), EditError> {
let mut probe = (*self.base).clone();
if let Some(dir) = self.dir_for(slug).filter(|d| d.is_dir()) {
let mut existing = Vec::new();
collect(&dir, &dir, &mut existing);
existing.sort_by(|a, b| a.0.cmp(&b.0));
for (n, b) in existing {
if n == name {
continue;
}
let _ = probe.add_raw_template(&n, &b);
}
}
probe
.add_raw_template(name, body)
.and_then(|()| probe.build_inheritance_chains())
.map_err(|e| EditError::Invalid(chain(&e)))
}
pub fn delete_override(&self, slug: &str, name: &str) -> Result<(), EditError> {
let name = safe_name(name)?;
let dir = self.dir_for(slug).ok_or(EditError::NotConfigured)?;
let path = dir.join(&name);
if !path.exists() {
return Ok(());
}
if !contained(&dir, &path) {
return Err(EditError::BadName(name));
}
std::fs::remove_file(&path).map_err(EditError::Io)?;
let mut p = path.parent().map(std::path::Path::to_path_buf);
while let Some(cur) = p {
if cur == dir || !cur.starts_with(&dir) {
break;
}
if std::fs::remove_dir(&cur).is_err() {
break;
}
p = cur.parent().map(std::path::Path::to_path_buf);
}
Ok(())
}
}
fn contained(root: &Path, path: &Path) -> bool {
let Ok(root_real) = root.canonicalize() else {
return false;
};
let mut probe = path.to_path_buf();
let mut tail: Vec<std::ffi::OsString> = Vec::new();
loop {
if let Ok(real) = probe.canonicalize() {
let mut full = real;
for seg in tail.iter().rev() {
full.push(seg);
}
return full.starts_with(&root_real);
}
let Some(name) = probe.file_name().map(std::ffi::OsStr::to_owned) else {
return false;
};
tail.push(name);
if !probe.pop() {
return false;
}
}
}
fn chain(e: &tera::Error) -> String {
let mut msg = e.to_string();
let mut src = std::error::Error::source(e);
while let Some(s) = src {
msg.push_str(": ");
msg.push_str(&s.to_string());
src = std::error::Error::source(s);
}
msg
}
pub async fn database_birth(
pool: &rustango::sql::Pool,
) -> Result<Option<String>, rustango::sql::ExecError> {
let as_text = match pool.dialect().name() {
"postgres" => "CAST(MIN(applied_at) AS TEXT)",
"mysql" => "CAST(MIN(applied_at) AS CHAR)",
_ => "MIN(applied_at)",
};
let sql = format!("SELECT {as_text} FROM __rustango_migrations__");
let rows: Vec<(Option<String>,)> = rustango::sql::raw_query_pool(&sql, Vec::new(), pool).await?;
Ok(rows.into_iter().next().and_then(|r| r.0))
}
static INSTALLED: std::sync::OnceLock<Arc<TenantTemplates>> = std::sync::OnceLock::new();
pub fn install(tt: Arc<TenantTemplates>) {
if INSTALLED.set(tt).is_err() {
tracing::error!(target: "rustango_cms", "install: tenant templates are already installed; this set is ignored");
}
}
#[must_use]
pub fn installed() -> Option<Arc<TenantTemplates>> {
INSTALLED.get().cloned()
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::atomic::{AtomicU32, Ordering};
static N: AtomicU32 = AtomicU32::new(0);
struct Scratch(PathBuf);
impl Scratch {
fn new() -> Self {
let p = std::env::temp_dir().join(format!(
"rcms-tt-{}-{}",
std::process::id(),
N.fetch_add(1, Ordering::Relaxed),
));
std::fs::create_dir_all(&p).expect("scratch");
Self(p)
}
fn write(&self, rel: &str, body: &str) {
let path = self.0.join(rel);
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
std::fs::write(path, body).unwrap();
}
}
impl Drop for Scratch {
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
fn global() -> Arc<Tera> {
let mut t = Tera::default();
t.add_raw_templates(vec![
("base.html", "GLOBAL-BASE[{% block body %}{% endblock %}]"),
("page.html", "{% extends \"base.html\" %}{% block body %}global-page{% endblock %}"),
("only_global.html", "only-global"),
])
.unwrap();
t.build_inheritance_chains().unwrap();
Arc::new(t)
}
fn render(t: &Tera, name: &str) -> String {
t.render(name, &tera::Context::new()).expect("render")
}
#[test]
fn a_tenant_without_a_directory_gets_the_global_set_itself() {
let s = Scratch::new();
let base = global();
let tt = TenantTemplates::new(Arc::clone(&base), &s.0);
let got = tt.for_tenant("nobody");
assert!(Arc::ptr_eq(&got, &base), "should hand back the global Arc");
assert_eq!(tt.cache.read().unwrap().len(), 0, "no cache entry either");
}
#[test]
fn a_tenant_template_wins_over_the_global_one_of_the_same_name() {
let s = Scratch::new();
s.write("acme/page.html", "acme-page");
let tt = TenantTemplates::new(global(), &s.0);
assert_eq!(render(&tt.for_tenant("acme"), "page.html"), "acme-page");
}
#[test]
fn anything_the_tenant_has_not_overridden_falls_back() {
let s = Scratch::new();
s.write("acme/page.html", "acme-page");
let tt = TenantTemplates::new(global(), &s.0);
let t = tt.for_tenant("acme");
assert_eq!(render(&t, "only_global.html"), "only-global");
}
#[test]
fn extends_resolves_to_the_tenants_base_not_the_global_one() {
let s = Scratch::new();
s.write("acme/base.html", "ACME-BASE[{% block body %}{% endblock %}]");
let tt = TenantTemplates::new(global(), &s.0);
let out = render(&tt.for_tenant("acme"), "page.html");
assert_eq!(out, "ACME-BASE[global-page]", "got {out}");
assert_eq!(render(&tt.for_tenant("other"), "page.html"), "GLOBAL-BASE[global-page]");
}
#[test]
fn nested_directories_keep_the_name_the_global_set_uses() {
let s = Scratch::new();
s.write("acme/blocks/hero.html", "acme-hero");
s.write("acme/page.html", "{% include \"blocks/hero.html\" %}");
let tt = TenantTemplates::new(global(), &s.0);
assert_eq!(render(&tt.for_tenant("acme"), "page.html"), "acme-hero");
}
#[test]
fn non_html_files_are_ignored() {
let s = Scratch::new();
s.write("acme/page.html", "acme-page");
s.write("acme/README.md", "not a template");
s.write("acme/style.css", "body{}");
let tt = TenantTemplates::new(global(), &s.0);
let t = tt.for_tenant("acme");
assert_eq!(render(&t, "page.html"), "acme-page");
assert!(t.get_template_names().all(|n| n.ends_with(".html")));
}
#[test]
fn a_repeat_lookup_reuses_the_built_instance() {
let s = Scratch::new();
s.write("acme/page.html", "acme-page");
let tt = TenantTemplates::new(global(), &s.0).with_reload(Reload::Never);
let a = tt.for_tenant("acme");
let b = tt.for_tenant("acme");
assert!(Arc::ptr_eq(&a, &b), "should not rebuild on every request");
}
#[test]
fn an_edit_is_picked_up_without_a_restart() {
let s = Scratch::new();
s.write("acme/page.html", "before");
let tt = TenantTemplates::new(global(), &s.0).with_reload(Reload::Always);
assert_eq!(render(&tt.for_tenant("acme"), "page.html"), "before");
s.write("acme/page.html", "after-and-longer");
assert_eq!(render(&tt.for_tenant("acme"), "page.html"), "after-and-longer");
}
#[test]
fn a_new_file_is_noticed_not_just_a_changed_one() {
let s = Scratch::new();
s.write("acme/page.html", "acme-page");
let tt = TenantTemplates::new(global(), &s.0).with_reload(Reload::Always);
let _ = tt.for_tenant("acme");
s.write("acme/only_global.html", "acme-now-owns-this");
assert_eq!(
render(&tt.for_tenant("acme"), "only_global.html"),
"acme-now-owns-this",
);
}
#[test]
fn reload_never_does_not_notice_an_edit() {
let s = Scratch::new();
s.write("acme/page.html", "before");
let tt = TenantTemplates::new(global(), &s.0).with_reload(Reload::Never);
assert_eq!(render(&tt.for_tenant("acme"), "page.html"), "before");
s.write("acme/page.html", "after-and-longer");
assert_eq!(render(&tt.for_tenant("acme"), "page.html"), "before");
}
#[test]
fn a_malformed_tenant_template_falls_back_instead_of_breaking_the_site() {
let s = Scratch::new();
s.write("acme/page.html", "{% for x in %}broken");
s.write("acme/only_global.html", "acme-fine");
let tt = TenantTemplates::new(global(), &s.0);
let t = tt.for_tenant("acme");
assert_eq!(render(&t, "page.html"), "GLOBAL-BASE[global-page]");
assert_eq!(render(&t, "only_global.html"), "acme-fine");
}
#[test]
fn a_slug_cannot_climb_out_of_the_root() {
let s = Scratch::new();
s.write("acme/page.html", "acme-page");
let tt = TenantTemplates::new(global(), &s.0);
for slug in ["..", ".", "", "../acme", "a/b", "a\\b"] {
assert!(tt.tenant_dir(slug).is_none(), "slug {slug:?} must be refused");
}
}
fn store(s: &Scratch) -> TenantTemplates {
s.write("_global/base.html", "GLOBAL-BASE[{% block body %}{% endblock %}]");
s.write("_global/page.html", "{% extends \"base.html\" %}{% block body %}g{% endblock %}");
TenantTemplates::new(global(), s.0.join("t")).with_global_dir(s.0.join("_global"))
}
#[test]
fn a_template_that_extends_a_global_parent_validates() {
let s = Scratch::new();
let tt = store(&s);
tt.write_override("acme", "page.html", "{% extends \"base.html\" %}{% block body %}a{% endblock %}")
.expect("extending a global parent is valid");
assert!(tt.read_override("acme", "page.html").unwrap().contains("{% block body %}a"));
}
#[test]
fn extending_a_parent_that_does_not_exist_is_refused() {
let s = Scratch::new();
let tt = store(&s);
let err = tt
.write_override("acme", "page.html", "{% extends \"nope.html\" %}")
.expect_err("must refuse");
assert!(matches!(err, EditError::Invalid(_)), "{err}");
assert!(err.to_string().contains("nope.html"), "{err}");
assert!(tt.read_override("acme", "page.html").is_none(), "nothing written");
}
#[test]
fn a_syntax_error_is_refused_with_a_useful_message() {
let s = Scratch::new();
let tt = store(&s);
let err = tt.write_override("acme", "x.html", "{% for a in %}").expect_err("must refuse");
assert!(err.to_string().len() > "Failed to parse 'x.html'".len(), "{err}");
}
#[test]
fn a_tenants_own_base_is_used_when_validating_its_other_templates() {
let s = Scratch::new();
let tt = store(&s);
tt.write_override("acme", "base.html", "A[{% block body %}{% endblock %}]").unwrap();
tt.write_override("acme", "page.html", "{% extends \"base.html\" %}{% block body %}x{% endblock %}")
.expect("valid against the tenant's own base");
}
#[test]
fn listing_marks_overrides_and_includes_inherited_names() {
let s = Scratch::new();
let tt = store(&s);
tt.write_override("acme", "page.html", "own").unwrap();
let rows = tt.list_for("acme");
let by: HashMap<&str, Source> = rows.iter().map(|e| (e.name.as_str(), e.source)).collect();
assert_eq!(by.get("page.html"), Some(&Source::Override));
assert_eq!(by.get("base.html"), Some(&Source::Global), "inherited names are listed too");
}
#[test]
fn deleting_an_override_reverts_to_the_global_one() {
let s = Scratch::new();
let tt = store(&s);
tt.write_override("acme", "page.html", "own").unwrap();
assert!(tt.read_override("acme", "page.html").is_some());
tt.delete_override("acme", "page.html").unwrap();
assert!(tt.read_override("acme", "page.html").is_none());
assert!(tt.read_global("page.html").is_some(), "global must survive");
}
#[test]
fn deleting_something_never_overridden_is_not_an_error() {
let s = Scratch::new();
let tt = store(&s);
tt.delete_override("acme", "page.html").expect("no-op, not a failure");
}
#[test]
fn a_name_that_escapes_the_tenant_directory_is_refused() {
for bad in ["../../evil.html", "a/../../b.html", "..", "../x.html",
".hidden.html", "notatemplate.txt", "", "x.html/"] {
assert!(safe_name(bad).is_err(), "{bad:?} must be refused");
}
for ok in ["page.html", "blocks/hero.html", "a/b/c.html", "/page.html"] {
assert!(safe_name(ok).is_ok(), "{ok:?} must be allowed");
}
}
#[test]
fn an_absolute_looking_name_is_confined_not_escaped() {
let s = Scratch::new();
let tt = store(&s);
let name = safe_name("/etc/passwd.html").expect("stripped to a relative name");
assert_eq!(name, "etc/passwd.html");
tt.write_override("acme", "/etc/passwd.html", "x").unwrap();
assert!(
s.0.join("t/acme/etc/passwd.html").exists(),
"must land under the tenant, as an oddly-named template",
);
assert!(
!std::path::Path::new("/etc/passwd.html").exists(),
"and must not have touched the real filesystem root",
);
}
#[test]
fn every_accepted_name_resolves_inside_the_tenant_directory() {
let s = Scratch::new();
let tt = store(&s);
let dir = tt.dir_for("acme").unwrap();
for candidate in ["page.html", "/page.html", "a/b/c.html", "/etc/passwd.html"] {
let name = safe_name(candidate).expect("accepted");
let path = dir.join(&name);
assert!(
path.starts_with(&dir),
"{candidate:?} resolved to {path:?}, outside {dir:?}",
);
}
}
#[test]
fn a_refused_write_leaves_no_file_behind() {
let s = Scratch::new();
let tt = store(&s);
assert!(tt.write_override("acme", "../escape.html", "x").is_err());
assert!(!s.0.join("escape.html").exists(), "must not write outside");
}
#[test]
fn a_nested_override_and_its_empty_parents_are_cleaned_up() {
let s = Scratch::new();
let tt = store(&s);
tt.write_override("acme", "blocks/deep/hero.html", "h").unwrap();
assert!(s.0.join("t/acme/blocks/deep/hero.html").exists());
tt.delete_override("acme", "blocks/deep/hero.html").unwrap();
assert!(!s.0.join("t/acme/blocks").exists(), "empty dirs tidied");
assert!(s.0.join("t/acme").exists(), "but not the tenant's own dir");
}
#[test]
fn an_edit_through_the_store_is_visible_to_the_renderer() {
let s = Scratch::new();
let tt = store(&s).with_reload(Reload::Always);
tt.write_override("acme", "page.html", "{% extends \"base.html\" %}{% block body %}EDITED{% endblock %}")
.unwrap();
let out = tt.for_tenant("acme").render("page.html", &tera::Context::new()).unwrap();
assert_eq!(out, "GLOBAL-BASE[EDITED]");
}
#[test]
fn the_renderable_set_includes_overrides_globals_and_baked_templates() {
let s = Scratch::new();
let tt = store(&s);
tt.write_override("acme", "own.html", "own").unwrap();
let names: Vec<String> = tt
.for_tenant("acme")
.get_template_names()
.map(str::to_owned)
.collect();
assert!(names.iter().any(|n| n == "own.html"), "tenant override: {names:?}");
assert!(names.iter().any(|n| n == "page.html"), "baked/global: {names:?}");
}
#[test]
fn a_name_the_tenant_cannot_render_is_absent_from_the_set() {
let s = Scratch::new();
let tt = store(&s);
let names: Vec<String> = tt
.for_tenant("acme")
.get_template_names()
.map(str::to_owned)
.collect();
assert!(!names.iter().any(|n| n == "does_not_exist.html"));
}
#[test]
#[ignore = "measurement, not a pass/fail check"]
fn cost_of_the_tenant_template_layer() {
use std::time::Instant;
let s = Scratch::new();
let mut base = Tera::default();
for i in 0..60 {
base.add_raw_template(&format!("bulk/t{i}.html"), "{% block b %}{% endblock %}x")
.unwrap();
}
base.add_raw_template("base.html", "B[{% block body %}{% endblock %}]").unwrap();
base.build_inheritance_chains().unwrap();
let base = Arc::new(base);
for n in [1usize, 5, 20] {
let slug = format!("t{n}");
for i in 0..n {
s.write(&format!("{slug}/f{i}.html"), "{% extends \"base.html\" %}{% block body %}y{% endblock %}");
}
let tt = TenantTemplates::new(Arc::clone(&base), &s.0);
let t0 = Instant::now();
let _ = tt.for_tenant(&slug);
let cold = t0.elapsed();
let t1 = Instant::now();
for _ in 0..10_000 { let _ = tt.for_tenant(&slug); }
let hit = t1.elapsed() / 10_000;
let dir = tt.dir_for(&slug).unwrap();
let t2 = Instant::now();
for _ in 0..1_000 { let _ = fingerprint(&dir); }
let fp = t2.elapsed() / 1_000;
println!(
" {n:>2} override(s): cold build {:>8.3?} | cached hit {:>8.3?} | fingerprint {:>8.3?}",
cold, hit, fp
);
}
let tt = TenantTemplates::new(Arc::clone(&base), &s.0);
let t = Instant::now();
for _ in 0..10_000 { let _ = tt.for_tenant("no-such-tenant"); }
println!(" no overrides: {:>8.3?} per call (returns the global Arc)", t.elapsed() / 10_000);
}
fn two_tenants(s: &Scratch) -> TenantTemplates {
s.write("_global/base.html", "GLOBAL-BASE[{% block body %}{% endblock %}]");
s.write("t/acme/own.html", "acme-own");
s.write("t/other/secret.html", "OTHER-TENANT-SECRET");
std::os::unix::fs::symlink(
s.0.join("t/other/secret.html"),
s.0.join("t/acme/peek.html"),
)
.expect("symlink");
TenantTemplates::new(global(), s.0.join("t")).with_global_dir(s.0.join("_global"))
}
#[test]
fn a_symlink_out_of_the_tenant_directory_cannot_be_read() {
let s = Scratch::new();
let tt = two_tenants(&s);
assert!(tt.read_override("acme", "peek.html").is_none(), "must not read through the link");
assert_eq!(tt.read_override("acme", "own.html").as_deref(), Some("acme-own"));
}
#[test]
fn a_symlink_out_of_the_tenant_directory_cannot_be_written_through() {
let s = Scratch::new();
let tt = two_tenants(&s);
let err = tt
.write_override("acme", "peek.html", "OVERWRITTEN")
.expect_err("must refuse");
assert!(matches!(err, EditError::BadName(_)), "{err}");
assert_eq!(
std::fs::read_to_string(s.0.join("t/other/secret.html")).unwrap(),
"OTHER-TENANT-SECRET",
"the other tenant's file must be untouched",
);
}
#[test]
fn a_symlink_out_of_the_tenant_directory_cannot_be_deleted_through() {
let s = Scratch::new();
let tt = two_tenants(&s);
assert!(tt.delete_override("acme", "peek.html").is_err());
assert!(s.0.join("t/other/secret.html").exists(), "target must survive");
}
#[test]
fn an_escaping_symlink_is_neither_listed_nor_rendered() {
let s = Scratch::new();
let tt = two_tenants(&s);
let names: Vec<String> = tt.list_for("acme").into_iter().map(|e| e.name).collect();
assert!(names.iter().any(|n| n == "own.html"), "{names:?}");
assert!(!names.iter().any(|n| n == "peek.html"), "escaping link listed: {names:?}");
let rendered: Vec<String> = tt
.for_tenant("acme")
.get_template_names()
.map(str::to_owned)
.collect();
assert!(!rendered.iter().any(|n| n == "peek.html"), "escaping link loaded: {rendered:?}");
}
#[test]
fn a_symlink_that_stays_inside_the_tenant_is_still_fine() {
let s = Scratch::new();
let tt = two_tenants(&s);
std::os::unix::fs::symlink(s.0.join("t/acme/own.html"), s.0.join("t/acme/alias.html"))
.expect("symlink");
assert_eq!(tt.read_override("acme", "alias.html").as_deref(), Some("acme-own"));
}
#[test]
fn one_tenant_cannot_reach_another_by_name_alone() {
let s = Scratch::new();
let tt = two_tenants(&s);
for name in ["../other/secret.html", "/../other/secret.html", "..%2Fother.html"] {
assert!(
tt.read_override("acme", name).is_none(),
"{name:?} must not resolve",
);
}
}
#[test]
fn the_cache_is_bounded_and_evicts_the_least_recently_used() {
let s = Scratch::new();
for i in 0..4 {
s.write(&format!("t{i}/page.html"), &format!("tenant-{i}"));
}
let tt = TenantTemplates::new(global(), &s.0)
.with_reload(Reload::Never)
.with_capacity(2);
let _ = tt.for_tenant("t0");
let _ = tt.for_tenant("t1");
let _ = tt.for_tenant("t0"); let _ = tt.for_tenant("t2");
let cache = tt.cache.read().unwrap();
assert_eq!(cache.len(), 2, "cache must stay bounded");
assert!(cache.contains_key("t0"), "recently used survives");
assert!(!cache.contains_key("t1"), "least recently used evicted");
}
#[test]
fn an_evicted_tenant_still_renders_correctly() {
let s = Scratch::new();
s.write("t0/page.html", "zero");
s.write("t1/page.html", "one");
let tt = TenantTemplates::new(global(), &s.0).with_capacity(1);
assert_eq!(render(&tt.for_tenant("t0"), "page.html"), "zero");
assert_eq!(render(&tt.for_tenant("t1"), "page.html"), "one");
assert_eq!(render(&tt.for_tenant("t0"), "page.html"), "zero");
}
#[test]
fn a_reused_slug_does_not_inherit_the_old_overrides() {
let s = Scratch::new();
s.write("acme/page.html", "OLD-CUSTOMER");
let tt = TenantTemplates::new(global(), &s.0);
assert_eq!(tt.claim("acme", "db-born-1").expect("claim"), Claim::Adopted);
assert_eq!(tt.claim("acme", "db-born-1").expect("claim"), Claim::Owned);
assert_eq!(render(&tt.for_tenant("acme"), "page.html"), "OLD-CUSTOMER");
match tt.claim("acme", "db-born-2").expect("claim") {
Claim::MovedAside { previous_owner, to } => {
assert_eq!(previous_owner, "db-born-1");
assert!(to.join("page.html").is_file(), "kept, not deleted");
}
other => panic!("expected the old directory moved aside, got {other:?}"),
}
assert_eq!(
render(&tt.for_tenant("acme"), "page.html"),
"GLOBAL-BASE[global-page]",
"the cached old instance is gone too"
);
assert_eq!(tt.claim("acme", "db-born-2").expect("claim"), Claim::NoOverrides);
assert!(tt.tenant_dir(".orphaned").is_none(), "the aside directory is no tenant's");
}
#[test]
fn the_owner_marker_is_not_a_template() {
let s = Scratch::new();
s.write("acme/page.html", "MINE");
let tt = TenantTemplates::new(global(), &s.0);
tt.claim("acme", "db").expect("claim");
assert_eq!(render(&tt.for_tenant("acme"), "page.html"), "MINE");
assert!(tt.for_tenant("acme").get_template(OWNER_FILE).is_err());
}
#[cfg(feature = "sqlite")]
#[tokio::test]
async fn database_birth_is_the_first_applied_migration() {
let pool = rustango::sql::Pool::connect("sqlite::memory:").await.expect("pool");
rustango::sql::raw_execute_pool(
&pool,
"CREATE TABLE __rustango_migrations__ (name TEXT PRIMARY KEY, applied_at TEXT NOT NULL)",
Vec::new(),
)
.await
.expect("ledger");
assert_eq!(database_birth(&pool).await.expect("empty"), None);
for (name, at) in [("0002_b", "2026-02-01T00:00:00+00:00"), ("0001_a", "2026-01-01T00:00:00+00:00")] {
rustango::sql::raw_execute_pool(
&pool,
&format!("INSERT INTO __rustango_migrations__ VALUES ('{name}', '{at}')"),
Vec::new(),
)
.await
.expect("row");
}
assert_eq!(
database_birth(&pool).await.expect("birth").as_deref(),
Some("2026-01-01T00:00:00+00:00")
);
}
#[test]
fn cached_serves_only_an_instance_not_due_a_check() {
let s = Scratch::new();
s.write("acme/page.html", "MINE");
let never = TenantTemplates::new(global(), &s.0).with_reload(Reload::Never);
assert!(never.cached("acme").is_none(), "nothing built yet");
let built = never.for_tenant("acme");
let hit = never.cached("acme").expect("cached after a build");
assert!(Arc::ptr_eq(&built, &hit));
let always = TenantTemplates::new(global(), &s.0).with_reload(Reload::Always);
let _ = always.for_tenant("acme");
assert!(always.cached("acme").is_none(), "always due: re-check on the blocking pool");
}
#[cfg(unix)]
#[test]
fn a_symlinked_subdirectory_creates_nothing_outside() {
let s = Scratch::new();
let outside = Scratch::new();
std::fs::create_dir_all(s.0.join("acme")).unwrap();
std::os::unix::fs::symlink(&outside.0, s.0.join("acme/evil")).unwrap();
let tt = TenantTemplates::new(global(), &s.0);
assert!(tt.write_override("acme", "evil/new/x.html", "x").is_err());
assert!(!outside.0.join("new").exists(), "no directory was created outside");
}
}