1use std::collections::HashMap;
61use std::path::{Path, PathBuf};
62use std::sync::atomic::{AtomicU64, Ordering};
63use std::sync::{Arc, RwLock};
64use std::time::{Duration, Instant, SystemTime};
65
66use tera::Tera;
67
68pub const DEFAULT_DIR: &str = "templates_tenants";
70
71#[derive(Debug, Clone, Copy, PartialEq, Eq)]
73pub enum Reload {
74 Always,
77 Every(Duration),
81 Never,
85}
86
87impl Default for Reload {
88 fn default() -> Self {
89 Self::Every(Duration::from_secs(5))
90 }
91}
92
93static TICK: AtomicU64 = AtomicU64::new(0);
99
100fn tick() -> u64 {
101 TICK.fetch_add(1, Ordering::Relaxed)
102}
103
104struct Entry {
106 tera: Arc<Tera>,
107 fingerprint: u64,
109 checked: Instant,
111 used: AtomicU64,
116}
117
118const OWNER_FILE: &str = ".rcms-owner";
121
122const ORPHANED_DIR: &str = ".orphaned";
125
126#[derive(Debug, PartialEq, Eq)]
128pub enum Claim {
129 NoOverrides,
131 Owned,
133 Adopted,
135 MovedAside { previous_owner: String, to: PathBuf },
138}
139
140pub struct TenantTemplates {
143 base: Arc<Tera>,
144 root: PathBuf,
145 global_dir: Option<PathBuf>,
150 reload: Reload,
151 capacity: usize,
152 cache: RwLock<HashMap<String, Entry>>,
153}
154
155impl TenantTemplates {
156 #[must_use]
160 pub fn new(base: Arc<Tera>, root: impl Into<PathBuf>) -> Self {
161 Self {
162 base,
163 root: root.into(),
164 global_dir: None,
165 reload: Reload::default(),
166 capacity: 64,
170 cache: RwLock::new(HashMap::new()),
171 }
172 }
173
174 #[must_use]
178 pub fn with_global_dir(mut self, dir: impl Into<PathBuf>) -> Self {
179 self.global_dir = Some(dir.into());
180 self
181 }
182
183 #[must_use]
184 pub fn with_reload(mut self, reload: Reload) -> Self {
185 self.reload = reload;
186 self
187 }
188
189 #[must_use]
190 pub fn with_capacity(mut self, capacity: usize) -> Self {
191 self.capacity = capacity.max(1);
192 self
193 }
194
195 #[must_use]
199 pub fn cached(&self, slug: &str) -> Option<Arc<Tera>> {
200 let cache = self.cache.read().ok()?;
201 let e = cache.get(slug)?;
202 if self.due(e) {
203 return None;
204 }
205 e.used.store(tick(), Ordering::Relaxed);
206 Some(Arc::clone(&e.tera))
207 }
208
209 #[must_use]
215 pub fn for_tenant(&self, slug: &str) -> Arc<Tera> {
216 let Some(dir) = self.tenant_dir(slug) else {
217 return Arc::clone(&self.base);
218 };
219
220 if let Ok(cache) = self.cache.read() {
222 if let Some(e) = cache.get(slug) {
223 if !self.due(e) {
224 e.used.store(tick(), Ordering::Relaxed);
225 return Arc::clone(&e.tera);
226 }
227 }
228 }
229
230 let fingerprint = fingerprint(&dir);
231
232 if let Ok(mut cache) = self.cache.write() {
235 if let Some(e) = cache.get_mut(slug) {
236 if e.fingerprint == fingerprint {
237 e.checked = Instant::now();
238 e.used.store(tick(), Ordering::Relaxed);
239 return Arc::clone(&e.tera);
240 }
241 }
242 }
243
244 let tera = Arc::new(self.build(&dir));
245
246 if let Ok(mut cache) = self.cache.write() {
247 if cache.len() >= self.capacity && !cache.contains_key(slug) {
248 Self::evict_lru(&mut cache);
249 }
250 cache.insert(
251 slug.to_owned(),
252 Entry {
253 tera: Arc::clone(&tera),
254 fingerprint,
255 checked: Instant::now(),
256 used: AtomicU64::new(tick()),
257 },
258 );
259 }
260 tera
261 }
262
263 fn due(&self, e: &Entry) -> bool {
265 match self.reload {
266 Reload::Always => true,
267 Reload::Never => false,
268 Reload::Every(d) => e.checked.elapsed() >= d,
269 }
270 }
271
272 fn evict_lru(cache: &mut HashMap<String, Entry>) {
273 if let Some(oldest) = cache
276 .iter()
277 .min_by_key(|(_, e)| e.used.load(Ordering::Relaxed))
278 .map(|(k, _)| k.clone())
279 {
280 cache.remove(&oldest);
281 }
282 }
283
284 fn tenant_dir(&self, slug: &str) -> Option<PathBuf> {
290 if slug.is_empty()
291 || slug.starts_with('.')
292 || slug.contains('/')
293 || slug.contains('\\')
294 {
295 return None;
296 }
297 let dir = self.root.join(slug);
298 dir.is_dir().then_some(dir)
299 }
300
301 pub fn claim(&self, slug: &str, owner: &str) -> std::io::Result<Claim> {
315 let Some(dir) = self.tenant_dir(slug) else {
316 return Ok(Claim::NoOverrides);
317 };
318 let marker = dir.join(OWNER_FILE);
319 match std::fs::read_to_string(&marker) {
320 Ok(found) if found.trim() == owner => Ok(Claim::Owned),
321 Ok(found) => {
322 let aside_root = self.root.join(ORPHANED_DIR);
323 std::fs::create_dir_all(&aside_root)?;
324 let stamp = SystemTime::now()
325 .duration_since(SystemTime::UNIX_EPOCH)
326 .map_or(0, |d| d.as_secs());
327 let aside = aside_root.join(format!("{slug}-{stamp}"));
328 std::fs::rename(&dir, &aside)?;
329 if let Ok(mut cache) = self.cache.write() {
330 cache.remove(slug);
331 }
332 Ok(Claim::MovedAside { previous_owner: found.trim().to_owned(), to: aside })
333 }
334 Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
335 std::fs::write(&marker, owner)?;
336 Ok(Claim::Adopted)
337 }
338 Err(e) => Err(e),
339 }
340 }
341
342 fn build(&self, dir: &Path) -> Tera {
344 let mut tera = (*self.base).clone();
345 let mut overrides: Vec<(String, String)> = Vec::new();
346 collect(dir, dir, &mut overrides);
347
348 overrides.sort_by(|a, b| a.0.cmp(&b.0));
352
353 for (name, body) in overrides {
354 if let Err(e) = tera.add_raw_template(&name, &body) {
355 tracing::warn!(
359 target: "rustango_cms::tenant_templates",
360 template = %name, error = %e,
361 "tenant template failed to parse; falling back to the global one",
362 );
363 }
364 }
365 if let Err(e) = tera.build_inheritance_chains() {
366 tracing::error!(
367 target: "rustango_cms::tenant_templates",
368 error = %e,
369 "tenant template inheritance is broken; serving the global set",
370 );
371 return (*self.base).clone();
372 }
373 tera
374 }
375}
376
377fn collect(root: &Path, dir: &Path, out: &mut Vec<(String, String)>) {
384 let Ok(entries) = std::fs::read_dir(dir) else {
385 return;
386 };
387 for entry in entries.flatten() {
388 let path = entry.path();
389 if !contained(root, &path) {
394 continue;
395 }
396 if path.is_dir() {
397 collect(root, &path, out);
398 continue;
399 }
400 if path.extension().and_then(|e| e.to_str()) != Some("html") {
401 continue;
402 }
403 let Ok(rel) = path.strip_prefix(root) else {
404 continue;
405 };
406 let name = rel
407 .components()
408 .filter_map(|c| c.as_os_str().to_str())
409 .collect::<Vec<_>>()
410 .join("/");
411 if let Ok(body) = std::fs::read_to_string(&path) {
412 out.push((name, body));
413 }
414 }
415}
416
417fn fingerprint(dir: &Path) -> u64 {
426 let mut files: Vec<(String, u64, u64)> = Vec::new();
427 let mut names: Vec<(String, String)> = Vec::new();
428 collect_meta(dir, dir, &mut names);
429 for (name, _) in &names {
430 let path = dir.join(name);
431 let (len, mtime) = std::fs::metadata(&path)
432 .map(|m| {
433 (
434 m.len(),
435 m.modified()
436 .ok()
437 .and_then(|t| t.duration_since(SystemTime::UNIX_EPOCH).ok())
438 .map_or(0, |d| d.as_nanos() as u64),
439 )
440 })
441 .unwrap_or((0, 0));
442 files.push((name.clone(), len, mtime));
443 }
444 files.sort();
445
446 let mut h: u64 = 0xcbf2_9ce4_8422_2325;
448 let mut eat = |bytes: &[u8]| {
449 for b in bytes {
450 h ^= u64::from(*b);
451 h = h.wrapping_mul(0x0000_0100_0000_01b3);
452 }
453 };
454 for (name, len, mtime) in &files {
455 eat(name.as_bytes());
456 eat(&len.to_le_bytes());
457 eat(&mtime.to_le_bytes());
458 }
459 h
460}
461
462fn collect_meta(root: &Path, dir: &Path, out: &mut Vec<(String, String)>) {
464 let Ok(entries) = std::fs::read_dir(dir) else {
465 return;
466 };
467 for entry in entries.flatten() {
468 let path = entry.path();
469 if !contained(root, &path) {
470 continue;
471 }
472 if path.is_dir() {
473 collect_meta(root, &path, out);
474 continue;
475 }
476 if path.extension().and_then(|e| e.to_str()) != Some("html") {
477 continue;
478 }
479 if let Ok(rel) = path.strip_prefix(root) {
480 let name = rel
481 .components()
482 .filter_map(|c| c.as_os_str().to_str())
483 .collect::<Vec<_>>()
484 .join("/");
485 out.push((name, String::new()));
486 }
487 }
488}
489
490#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
492#[serde(rename_all = "lowercase")]
493pub enum Source {
494 Override,
496 Global,
498}
499
500#[derive(Debug, Clone, serde::Serialize)]
502pub struct TemplateEntry {
503 pub name: String,
504 pub source: Source,
505 pub bytes: u64,
506}
507
508#[derive(Debug)]
510pub enum EditError {
511 BadName(String),
513 Invalid(String),
516 NotConfigured,
518 Io(std::io::Error),
519}
520
521impl std::fmt::Display for EditError {
522 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
523 match self {
524 Self::BadName(n) => write!(f, "`{n}` is not a valid template name"),
525 Self::Invalid(e) => write!(f, "{e}"),
526 Self::NotConfigured => write!(f, "per-tenant templates are not configured"),
527 Self::Io(e) => write!(f, "{e}"),
528 }
529 }
530}
531
532pub fn safe_name(name: &str) -> Result<String, EditError> {
542 let n = name.trim().trim_start_matches('/');
543 let bad = n.is_empty()
544 || !n.ends_with(".html")
545 || n.contains('\\')
546 || n.starts_with('.')
547 || n.split('/').any(|seg| seg.is_empty() || seg == "." || seg == "..")
548 || std::path::Path::new(n).is_absolute();
549 if bad {
550 return Err(EditError::BadName(name.to_owned()));
551 }
552 Ok(n.to_owned())
553}
554
555impl TenantTemplates {
556 #[must_use]
558 pub fn dir_for(&self, slug: &str) -> Option<PathBuf> {
559 if slug.is_empty() || slug.contains('/') || slug.contains('\\') || slug.starts_with('.') {
560 return None;
561 }
562 Some(self.root.join(slug))
563 }
564
565 #[must_use]
568 pub fn list_for(&self, slug: &str) -> Vec<TemplateEntry> {
569 let mut seen: HashMap<String, TemplateEntry> = HashMap::new();
570
571 if let Some(g) = &self.global_dir {
572 let mut names = Vec::new();
573 collect_meta(g, g, &mut names);
574 for (name, _) in names {
575 let bytes = std::fs::metadata(g.join(&name)).map(|m| m.len()).unwrap_or(0);
576 seen.insert(name.clone(), TemplateEntry { name, source: Source::Global, bytes });
577 }
578 }
579 if let Some(dir) = self.dir_for(slug).filter(|d| d.is_dir()) {
580 let mut names = Vec::new();
581 collect_meta(&dir, &dir, &mut names);
582 for (name, _) in names {
583 let bytes = std::fs::metadata(dir.join(&name)).map(|m| m.len()).unwrap_or(0);
584 seen.insert(name.clone(), TemplateEntry { name, source: Source::Override, bytes });
585 }
586 }
587 let mut out: Vec<TemplateEntry> = seen.into_values().collect();
588 out.sort_by(|a, b| a.name.cmp(&b.name));
589 out
590 }
591
592 #[must_use]
594 pub fn read_override(&self, slug: &str, name: &str) -> Option<String> {
595 let name = safe_name(name).ok()?;
596 let dir = self.dir_for(slug)?;
597 let path = dir.join(name);
598 if !contained(&dir, &path) {
599 return None;
600 }
601 std::fs::read_to_string(path).ok()
602 }
603
604 #[must_use]
607 pub fn read_global(&self, name: &str) -> Option<String> {
608 let name = safe_name(name).ok()?;
609 std::fs::read_to_string(self.global_dir.as_ref()?.join(name)).ok()
610 }
611
612 pub fn write_override(&self, slug: &str, name: &str, body: &str) -> Result<(), EditError> {
622 let name = safe_name(name)?;
623 let dir = self.dir_for(slug).ok_or(EditError::NotConfigured)?;
624
625 self.validate(slug, &name, body)?;
626
627 let path = dir.join(&name);
628 std::fs::create_dir_all(&dir).map_err(EditError::Io)?;
634 if !contained(&dir, &path) {
635 return Err(EditError::BadName(name));
636 }
637 if let Some(parent) = path.parent() {
638 std::fs::create_dir_all(parent).map_err(EditError::Io)?;
639 }
640 std::fs::write(&path, body).map_err(EditError::Io)?;
641 Ok(())
642 }
643
644 pub fn validate(&self, slug: &str, name: &str, body: &str) -> Result<(), EditError> {
661 let mut probe = (*self.base).clone();
662
663 if let Some(dir) = self.dir_for(slug).filter(|d| d.is_dir()) {
664 let mut existing = Vec::new();
665 collect(&dir, &dir, &mut existing);
666 existing.sort_by(|a, b| a.0.cmp(&b.0));
667 for (n, b) in existing {
668 if n == name {
672 continue;
673 }
674 let _ = probe.add_raw_template(&n, &b);
675 }
676 }
677
678 probe
679 .add_raw_template(name, body)
680 .and_then(|()| probe.build_inheritance_chains())
681 .map_err(|e| EditError::Invalid(chain(&e)))
682 }
683
684 pub fn delete_override(&self, slug: &str, name: &str) -> Result<(), EditError> {
691 let name = safe_name(name)?;
692 let dir = self.dir_for(slug).ok_or(EditError::NotConfigured)?;
693 let path = dir.join(&name);
694 if !path.exists() {
695 return Ok(());
696 }
697 if !contained(&dir, &path) {
698 return Err(EditError::BadName(name));
699 }
700 std::fs::remove_file(&path).map_err(EditError::Io)?;
701 let mut p = path.parent().map(std::path::Path::to_path_buf);
704 while let Some(cur) = p {
705 if cur == dir || !cur.starts_with(&dir) {
706 break;
707 }
708 if std::fs::remove_dir(&cur).is_err() {
709 break;
710 }
711 p = cur.parent().map(std::path::Path::to_path_buf);
712 }
713 Ok(())
714 }
715
716 pub fn write_set(&self, slug: &str, files: &[(String, String)]) -> Result<usize, EditError> {
729 let dir = self.dir_for(slug).ok_or(EditError::NotConfigured)?;
730 let mut named = Vec::with_capacity(files.len());
731 for (name, body) in files {
732 named.push((safe_name(name)?, body.as_str()));
733 }
734
735 let mut probe = (*self.base).clone();
736 if dir.is_dir() {
737 let mut existing = Vec::new();
738 collect(&dir, &dir, &mut existing);
739 for (n, b) in existing {
740 if !named.iter().any(|(m, _)| *m == n) {
741 let _ = probe.add_raw_template(&n, &b);
742 }
743 }
744 }
745 probe
746 .add_raw_templates(named.iter().map(|(n, b)| (n.as_str(), *b)))
747 .map_err(|e| EditError::Invalid(chain(&e)))?;
748
749 std::fs::create_dir_all(&dir).map_err(EditError::Io)?;
750 for (name, body) in &named {
751 let path = dir.join(name);
752 if let Some(parent) = path.parent() {
753 std::fs::create_dir_all(parent).map_err(EditError::Io)?;
754 }
755 if !contained(&dir, path.parent().unwrap_or(&dir)) {
756 return Err(EditError::BadName(name.clone()));
757 }
758 std::fs::write(&path, body).map_err(EditError::Io)?;
759 }
760 Ok(named.len())
761 }
762
763 fn snapshot_dir(&self, slug: &str) -> Option<PathBuf> {
766 self.dir_for(slug)?;
767 Some(self.root.join(".previous").join(slug))
768 }
769
770 pub fn snapshot(&self, slug: &str) -> Result<(), EditError> {
777 let dir = self.dir_for(slug).ok_or(EditError::NotConfigured)?;
778 let snap = self.snapshot_dir(slug).ok_or(EditError::NotConfigured)?;
779 if snap.exists() {
780 std::fs::remove_dir_all(&snap).map_err(EditError::Io)?;
781 }
782 std::fs::create_dir_all(&snap).map_err(EditError::Io)?;
783 if dir.is_dir() {
784 let mut files = Vec::new();
785 collect(&dir, &dir, &mut files);
786 for (name, body) in files {
787 let path = snap.join(&name);
788 if let Some(parent) = path.parent() {
789 std::fs::create_dir_all(parent).map_err(EditError::Io)?;
790 }
791 std::fs::write(path, body).map_err(EditError::Io)?;
792 }
793 }
794 Ok(())
795 }
796
797 #[must_use]
799 pub fn has_snapshot(&self, slug: &str) -> bool {
800 self.snapshot_dir(slug).is_some_and(|d| d.is_dir())
801 }
802
803 pub fn restore_snapshot(&self, slug: &str) -> Result<(), EditError> {
811 let dir = self.dir_for(slug).ok_or(EditError::NotConfigured)?;
812 let snap = self
813 .snapshot_dir(slug)
814 .filter(|d| d.is_dir())
815 .ok_or(EditError::NotConfigured)?;
816 let swap = self.root.join(".previous").join(format!("{slug}.swap"));
817 if swap.exists() {
818 std::fs::remove_dir_all(&swap).map_err(EditError::Io)?;
819 }
820 if dir.exists() {
821 std::fs::rename(&dir, &swap).map_err(EditError::Io)?;
822 } else {
823 std::fs::create_dir_all(&swap).map_err(EditError::Io)?;
824 }
825 std::fs::rename(&snap, &dir).map_err(EditError::Io)?;
826 std::fs::rename(&swap, &snap).map_err(EditError::Io)?;
827 Ok(())
828 }
829}
830
831fn contained(root: &Path, path: &Path) -> bool {
845 let Ok(root_real) = root.canonicalize() else {
846 return false;
847 };
848 let mut probe = path.to_path_buf();
849 let mut tail: Vec<std::ffi::OsString> = Vec::new();
850 loop {
851 if let Ok(real) = probe.canonicalize() {
852 let mut full = real;
853 for seg in tail.iter().rev() {
854 full.push(seg);
855 }
856 return full.starts_with(&root_real);
857 }
858 let Some(name) = probe.file_name().map(std::ffi::OsStr::to_owned) else {
859 return false;
860 };
861 tail.push(name);
862 if !probe.pop() {
863 return false;
864 }
865 }
866}
867
868fn chain(e: &tera::Error) -> String {
874 let mut msg = e.to_string();
875 let mut src = std::error::Error::source(e);
876 while let Some(s) = src {
877 msg.push_str(": ");
878 msg.push_str(&s.to_string());
879 src = std::error::Error::source(s);
880 }
881 msg
882}
883
884pub async fn database_birth(
897 pool: &rustango::sql::Pool,
898) -> Result<Option<String>, rustango::sql::ExecError> {
899 let as_text = match pool.dialect().name() {
902 "postgres" => "CAST(MIN(applied_at) AS TEXT)",
903 "mysql" => "CAST(MIN(applied_at) AS CHAR)",
904 _ => "MIN(applied_at)",
905 };
906 let sql = format!("SELECT {as_text} FROM __rustango_migrations__");
908 let rows: Vec<(Option<String>,)> = rustango::sql::raw_query_pool(&sql, Vec::new(), pool).await?;
909 Ok(rows.into_iter().next().and_then(|r| r.0))
910}
911
912static INSTALLED: std::sync::OnceLock<Arc<TenantTemplates>> = std::sync::OnceLock::new();
913
914pub fn install(tt: Arc<TenantTemplates>) {
916 if INSTALLED.set(tt).is_err() {
918 tracing::error!(target: "rustango_cms", "install: tenant templates are already installed; this set is ignored");
919 }
920}
921
922#[must_use]
924pub fn installed() -> Option<Arc<TenantTemplates>> {
925 INSTALLED.get().cloned()
926}
927
928#[cfg(test)]
929mod tests {
930 use super::*;
931 use std::sync::atomic::{AtomicU32, Ordering};
932
933 static N: AtomicU32 = AtomicU32::new(0);
934
935 struct Scratch(PathBuf);
938 impl Scratch {
939 fn new() -> Self {
940 let p = std::env::temp_dir().join(format!(
941 "rcms-tt-{}-{}",
942 std::process::id(),
943 N.fetch_add(1, Ordering::Relaxed),
944 ));
945 std::fs::create_dir_all(&p).expect("scratch");
946 Self(p)
947 }
948 fn write(&self, rel: &str, body: &str) {
949 let path = self.0.join(rel);
950 std::fs::create_dir_all(path.parent().unwrap()).unwrap();
951 std::fs::write(path, body).unwrap();
952 }
953 }
954 impl Drop for Scratch {
955 fn drop(&mut self) {
956 let _ = std::fs::remove_dir_all(&self.0);
957 }
958 }
959
960 fn global() -> Arc<Tera> {
962 let mut t = Tera::default();
963 t.add_raw_templates(vec![
964 ("base.html", "GLOBAL-BASE[{% block body %}{% endblock %}]"),
965 ("page.html", "{% extends \"base.html\" %}{% block body %}global-page{% endblock %}"),
966 ("only_global.html", "only-global"),
967 ])
968 .unwrap();
969 t.build_inheritance_chains().unwrap();
970 Arc::new(t)
971 }
972
973 fn render(t: &Tera, name: &str) -> String {
974 t.render(name, &tera::Context::new()).expect("render")
975 }
976
977 #[test]
978 fn a_tenant_without_a_directory_gets_the_global_set_itself() {
979 let s = Scratch::new();
982 let base = global();
983 let tt = TenantTemplates::new(Arc::clone(&base), &s.0);
984 let got = tt.for_tenant("nobody");
985 assert!(Arc::ptr_eq(&got, &base), "should hand back the global Arc");
986 assert_eq!(tt.cache.read().unwrap().len(), 0, "no cache entry either");
987 }
988
989 #[test]
990 fn a_tenant_template_wins_over_the_global_one_of_the_same_name() {
991 let s = Scratch::new();
992 s.write("acme/page.html", "acme-page");
993 let tt = TenantTemplates::new(global(), &s.0);
994 assert_eq!(render(&tt.for_tenant("acme"), "page.html"), "acme-page");
995 }
996
997 #[test]
998 fn anything_the_tenant_has_not_overridden_falls_back() {
999 let s = Scratch::new();
1000 s.write("acme/page.html", "acme-page");
1001 let tt = TenantTemplates::new(global(), &s.0);
1002 let t = tt.for_tenant("acme");
1003 assert_eq!(render(&t, "only_global.html"), "only-global");
1004 }
1005
1006 #[test]
1007 fn extends_resolves_to_the_tenants_base_not_the_global_one() {
1008 let s = Scratch::new();
1013 s.write("acme/base.html", "ACME-BASE[{% block body %}{% endblock %}]");
1014 let tt = TenantTemplates::new(global(), &s.0);
1015 let out = render(&tt.for_tenant("acme"), "page.html");
1016 assert_eq!(out, "ACME-BASE[global-page]", "got {out}");
1017
1018 assert_eq!(render(&tt.for_tenant("other"), "page.html"), "GLOBAL-BASE[global-page]");
1020 }
1021
1022 #[test]
1023 fn nested_directories_keep_the_name_the_global_set_uses() {
1024 let s = Scratch::new();
1027 s.write("acme/blocks/hero.html", "acme-hero");
1028 s.write("acme/page.html", "{% include \"blocks/hero.html\" %}");
1029 let tt = TenantTemplates::new(global(), &s.0);
1030 assert_eq!(render(&tt.for_tenant("acme"), "page.html"), "acme-hero");
1031 }
1032
1033 #[test]
1034 fn non_html_files_are_ignored() {
1035 let s = Scratch::new();
1036 s.write("acme/page.html", "acme-page");
1037 s.write("acme/README.md", "not a template");
1038 s.write("acme/style.css", "body{}");
1039 let tt = TenantTemplates::new(global(), &s.0);
1040 let t = tt.for_tenant("acme");
1041 assert_eq!(render(&t, "page.html"), "acme-page");
1042 assert!(t.get_template_names().all(|n| n.ends_with(".html")));
1043 }
1044
1045 #[test]
1046 fn a_repeat_lookup_reuses_the_built_instance() {
1047 let s = Scratch::new();
1048 s.write("acme/page.html", "acme-page");
1049 let tt = TenantTemplates::new(global(), &s.0).with_reload(Reload::Never);
1050 let a = tt.for_tenant("acme");
1051 let b = tt.for_tenant("acme");
1052 assert!(Arc::ptr_eq(&a, &b), "should not rebuild on every request");
1053 }
1054
1055 #[test]
1056 fn an_edit_is_picked_up_without_a_restart() {
1057 let s = Scratch::new();
1060 s.write("acme/page.html", "before");
1061 let tt = TenantTemplates::new(global(), &s.0).with_reload(Reload::Always);
1062 assert_eq!(render(&tt.for_tenant("acme"), "page.html"), "before");
1063
1064 s.write("acme/page.html", "after-and-longer");
1065 assert_eq!(render(&tt.for_tenant("acme"), "page.html"), "after-and-longer");
1066 }
1067
1068 #[test]
1069 fn a_new_file_is_noticed_not_just_a_changed_one() {
1070 let s = Scratch::new();
1071 s.write("acme/page.html", "acme-page");
1072 let tt = TenantTemplates::new(global(), &s.0).with_reload(Reload::Always);
1073 let _ = tt.for_tenant("acme");
1074
1075 s.write("acme/only_global.html", "acme-now-owns-this");
1076 assert_eq!(
1077 render(&tt.for_tenant("acme"), "only_global.html"),
1078 "acme-now-owns-this",
1079 );
1080 }
1081
1082 #[test]
1083 fn reload_never_does_not_notice_an_edit() {
1084 let s = Scratch::new();
1086 s.write("acme/page.html", "before");
1087 let tt = TenantTemplates::new(global(), &s.0).with_reload(Reload::Never);
1088 assert_eq!(render(&tt.for_tenant("acme"), "page.html"), "before");
1089 s.write("acme/page.html", "after-and-longer");
1090 assert_eq!(render(&tt.for_tenant("acme"), "page.html"), "before");
1091 }
1092
1093 #[test]
1094 fn a_malformed_tenant_template_falls_back_instead_of_breaking_the_site() {
1095 let s = Scratch::new();
1097 s.write("acme/page.html", "{% for x in %}broken");
1098 s.write("acme/only_global.html", "acme-fine");
1099 let tt = TenantTemplates::new(global(), &s.0);
1100 let t = tt.for_tenant("acme");
1101 assert_eq!(render(&t, "page.html"), "GLOBAL-BASE[global-page]");
1102 assert_eq!(render(&t, "only_global.html"), "acme-fine");
1103 }
1104
1105 #[test]
1106 fn a_slug_cannot_climb_out_of_the_root() {
1107 let s = Scratch::new();
1110 s.write("acme/page.html", "acme-page");
1111 let tt = TenantTemplates::new(global(), &s.0);
1112 for slug in ["..", ".", "", "../acme", "a/b", "a\\b"] {
1113 assert!(tt.tenant_dir(slug).is_none(), "slug {slug:?} must be refused");
1114 }
1115 }
1116
1117 fn store(s: &Scratch) -> TenantTemplates {
1120 s.write("_global/base.html", "GLOBAL-BASE[{% block body %}{% endblock %}]");
1122 s.write("_global/page.html", "{% extends \"base.html\" %}{% block body %}g{% endblock %}");
1123 TenantTemplates::new(global(), s.0.join("t")).with_global_dir(s.0.join("_global"))
1124 }
1125
1126 #[test]
1127 fn a_template_that_extends_a_global_parent_validates() {
1128 let s = Scratch::new();
1132 let tt = store(&s);
1133 tt.write_override("acme", "page.html", "{% extends \"base.html\" %}{% block body %}a{% endblock %}")
1134 .expect("extending a global parent is valid");
1135 assert!(tt.read_override("acme", "page.html").unwrap().contains("{% block body %}a"));
1136 }
1137
1138 #[test]
1139 fn extending_a_parent_that_does_not_exist_is_refused() {
1140 let s = Scratch::new();
1143 let tt = store(&s);
1144 let err = tt
1145 .write_override("acme", "page.html", "{% extends \"nope.html\" %}")
1146 .expect_err("must refuse");
1147 assert!(matches!(err, EditError::Invalid(_)), "{err}");
1148 assert!(err.to_string().contains("nope.html"), "{err}");
1149 assert!(tt.read_override("acme", "page.html").is_none(), "nothing written");
1150 }
1151
1152 #[test]
1153 fn a_syntax_error_is_refused_with_a_useful_message() {
1154 let s = Scratch::new();
1155 let tt = store(&s);
1156 let err = tt.write_override("acme", "x.html", "{% for a in %}").expect_err("must refuse");
1157 assert!(err.to_string().len() > "Failed to parse 'x.html'".len(), "{err}");
1160 }
1161
1162 #[test]
1163 fn a_tenants_own_base_is_used_when_validating_its_other_templates() {
1164 let s = Scratch::new();
1167 let tt = store(&s);
1168 tt.write_override("acme", "base.html", "A[{% block body %}{% endblock %}]").unwrap();
1169 tt.write_override("acme", "page.html", "{% extends \"base.html\" %}{% block body %}x{% endblock %}")
1170 .expect("valid against the tenant's own base");
1171 }
1172
1173 #[test]
1174 fn listing_marks_overrides_and_includes_inherited_names() {
1175 let s = Scratch::new();
1176 let tt = store(&s);
1177 tt.write_override("acme", "page.html", "own").unwrap();
1178 let rows = tt.list_for("acme");
1179 let by: HashMap<&str, Source> = rows.iter().map(|e| (e.name.as_str(), e.source)).collect();
1180 assert_eq!(by.get("page.html"), Some(&Source::Override));
1181 assert_eq!(by.get("base.html"), Some(&Source::Global), "inherited names are listed too");
1182 }
1183
1184 #[test]
1185 fn deleting_an_override_reverts_to_the_global_one() {
1186 let s = Scratch::new();
1187 let tt = store(&s);
1188 tt.write_override("acme", "page.html", "own").unwrap();
1189 assert!(tt.read_override("acme", "page.html").is_some());
1190 tt.delete_override("acme", "page.html").unwrap();
1191 assert!(tt.read_override("acme", "page.html").is_none());
1192 assert!(tt.read_global("page.html").is_some(), "global must survive");
1194 }
1195
1196 #[test]
1197 fn deleting_something_never_overridden_is_not_an_error() {
1198 let s = Scratch::new();
1199 let tt = store(&s);
1200 tt.delete_override("acme", "page.html").expect("no-op, not a failure");
1201 }
1202
1203 #[test]
1204 fn a_name_that_escapes_the_tenant_directory_is_refused() {
1205 for bad in ["../../evil.html", "a/../../b.html", "..", "../x.html",
1208 ".hidden.html", "notatemplate.txt", "", "x.html/"] {
1209 assert!(safe_name(bad).is_err(), "{bad:?} must be refused");
1210 }
1211 for ok in ["page.html", "blocks/hero.html", "a/b/c.html", "/page.html"] {
1212 assert!(safe_name(ok).is_ok(), "{ok:?} must be allowed");
1213 }
1214 }
1215
1216 #[test]
1217 fn an_absolute_looking_name_is_confined_not_escaped() {
1218 let s = Scratch::new();
1223 let tt = store(&s);
1224 let name = safe_name("/etc/passwd.html").expect("stripped to a relative name");
1225 assert_eq!(name, "etc/passwd.html");
1226
1227 tt.write_override("acme", "/etc/passwd.html", "x").unwrap();
1228 assert!(
1229 s.0.join("t/acme/etc/passwd.html").exists(),
1230 "must land under the tenant, as an oddly-named template",
1231 );
1232 assert!(
1233 !std::path::Path::new("/etc/passwd.html").exists(),
1234 "and must not have touched the real filesystem root",
1235 );
1236 }
1237
1238 #[test]
1239 fn every_accepted_name_resolves_inside_the_tenant_directory() {
1240 let s = Scratch::new();
1243 let tt = store(&s);
1244 let dir = tt.dir_for("acme").unwrap();
1245 for candidate in ["page.html", "/page.html", "a/b/c.html", "/etc/passwd.html"] {
1246 let name = safe_name(candidate).expect("accepted");
1247 let path = dir.join(&name);
1248 assert!(
1249 path.starts_with(&dir),
1250 "{candidate:?} resolved to {path:?}, outside {dir:?}",
1251 );
1252 }
1253 }
1254
1255 #[test]
1256 fn a_refused_write_leaves_no_file_behind() {
1257 let s = Scratch::new();
1258 let tt = store(&s);
1259 assert!(tt.write_override("acme", "../escape.html", "x").is_err());
1260 assert!(!s.0.join("escape.html").exists(), "must not write outside");
1261 }
1262
1263 #[test]
1264 fn a_nested_override_and_its_empty_parents_are_cleaned_up() {
1265 let s = Scratch::new();
1266 let tt = store(&s);
1267 tt.write_override("acme", "blocks/deep/hero.html", "h").unwrap();
1268 assert!(s.0.join("t/acme/blocks/deep/hero.html").exists());
1269 tt.delete_override("acme", "blocks/deep/hero.html").unwrap();
1270 assert!(!s.0.join("t/acme/blocks").exists(), "empty dirs tidied");
1271 assert!(s.0.join("t/acme").exists(), "but not the tenant's own dir");
1272 }
1273
1274 #[test]
1275 fn an_edit_through_the_store_is_visible_to_the_renderer() {
1276 let s = Scratch::new();
1279 let tt = store(&s).with_reload(Reload::Always);
1280 tt.write_override("acme", "page.html", "{% extends \"base.html\" %}{% block body %}EDITED{% endblock %}")
1281 .unwrap();
1282 let out = tt.for_tenant("acme").render("page.html", &tera::Context::new()).unwrap();
1283 assert_eq!(out, "GLOBAL-BASE[EDITED]");
1284 }
1285
1286 #[test]
1287 fn the_renderable_set_includes_overrides_globals_and_baked_templates() {
1288 let s = Scratch::new();
1293 let tt = store(&s);
1294 tt.write_override("acme", "own.html", "own").unwrap();
1295 let names: Vec<String> = tt
1296 .for_tenant("acme")
1297 .get_template_names()
1298 .map(str::to_owned)
1299 .collect();
1300 assert!(names.iter().any(|n| n == "own.html"), "tenant override: {names:?}");
1301 assert!(names.iter().any(|n| n == "page.html"), "baked/global: {names:?}");
1302 }
1303
1304 #[test]
1305 fn a_name_the_tenant_cannot_render_is_absent_from_the_set() {
1306 let s = Scratch::new();
1310 let tt = store(&s);
1311 let names: Vec<String> = tt
1312 .for_tenant("acme")
1313 .get_template_names()
1314 .map(str::to_owned)
1315 .collect();
1316 assert!(!names.iter().any(|n| n == "does_not_exist.html"));
1317 }
1318
1319 #[test]
1322 #[ignore = "measurement, not a pass/fail check"]
1323 fn cost_of_the_tenant_template_layer() {
1324 use std::time::Instant;
1325 let s = Scratch::new();
1326 let mut base = Tera::default();
1329 for i in 0..60 {
1330 base.add_raw_template(&format!("bulk/t{i}.html"), "{% block b %}{% endblock %}x")
1331 .unwrap();
1332 }
1333 base.add_raw_template("base.html", "B[{% block body %}{% endblock %}]").unwrap();
1334 base.build_inheritance_chains().unwrap();
1335 let base = Arc::new(base);
1336
1337 for n in [1usize, 5, 20] {
1338 let slug = format!("t{n}");
1339 for i in 0..n {
1340 s.write(&format!("{slug}/f{i}.html"), "{% extends \"base.html\" %}{% block body %}y{% endblock %}");
1341 }
1342 let tt = TenantTemplates::new(Arc::clone(&base), &s.0);
1343
1344 let t0 = Instant::now();
1345 let _ = tt.for_tenant(&slug);
1346 let cold = t0.elapsed();
1347
1348 let t1 = Instant::now();
1349 for _ in 0..10_000 { let _ = tt.for_tenant(&slug); }
1350 let hit = t1.elapsed() / 10_000;
1351
1352 let dir = tt.dir_for(&slug).unwrap();
1353 let t2 = Instant::now();
1354 for _ in 0..1_000 { let _ = fingerprint(&dir); }
1355 let fp = t2.elapsed() / 1_000;
1356
1357 println!(
1358 " {n:>2} override(s): cold build {:>8.3?} | cached hit {:>8.3?} | fingerprint {:>8.3?}",
1359 cold, hit, fp
1360 );
1361 }
1362
1363 let tt = TenantTemplates::new(Arc::clone(&base), &s.0);
1364 let t = Instant::now();
1365 for _ in 0..10_000 { let _ = tt.for_tenant("no-such-tenant"); }
1366 println!(" no overrides: {:>8.3?} per call (returns the global Arc)", t.elapsed() / 10_000);
1367 }
1368
1369 fn two_tenants(s: &Scratch) -> TenantTemplates {
1373 s.write("_global/base.html", "GLOBAL-BASE[{% block body %}{% endblock %}]");
1374 s.write("t/acme/own.html", "acme-own");
1375 s.write("t/other/secret.html", "OTHER-TENANT-SECRET");
1376 std::os::unix::fs::symlink(
1377 s.0.join("t/other/secret.html"),
1378 s.0.join("t/acme/peek.html"),
1379 )
1380 .expect("symlink");
1381 TenantTemplates::new(global(), s.0.join("t")).with_global_dir(s.0.join("_global"))
1382 }
1383
1384 #[test]
1385 fn a_symlink_out_of_the_tenant_directory_cannot_be_read() {
1386 let s = Scratch::new();
1391 let tt = two_tenants(&s);
1392 assert!(tt.read_override("acme", "peek.html").is_none(), "must not read through the link");
1393 assert_eq!(tt.read_override("acme", "own.html").as_deref(), Some("acme-own"));
1394 }
1395
1396 #[test]
1397 fn a_symlink_out_of_the_tenant_directory_cannot_be_written_through() {
1398 let s = Scratch::new();
1401 let tt = two_tenants(&s);
1402 let err = tt
1403 .write_override("acme", "peek.html", "OVERWRITTEN")
1404 .expect_err("must refuse");
1405 assert!(matches!(err, EditError::BadName(_)), "{err}");
1406 assert_eq!(
1407 std::fs::read_to_string(s.0.join("t/other/secret.html")).unwrap(),
1408 "OTHER-TENANT-SECRET",
1409 "the other tenant's file must be untouched",
1410 );
1411 }
1412
1413 #[test]
1414 fn a_symlink_out_of_the_tenant_directory_cannot_be_deleted_through() {
1415 let s = Scratch::new();
1416 let tt = two_tenants(&s);
1417 assert!(tt.delete_override("acme", "peek.html").is_err());
1418 assert!(s.0.join("t/other/secret.html").exists(), "target must survive");
1419 }
1420
1421 #[test]
1422 fn an_escaping_symlink_is_neither_listed_nor_rendered() {
1423 let s = Scratch::new();
1427 let tt = two_tenants(&s);
1428 let names: Vec<String> = tt.list_for("acme").into_iter().map(|e| e.name).collect();
1429 assert!(names.iter().any(|n| n == "own.html"), "{names:?}");
1430 assert!(!names.iter().any(|n| n == "peek.html"), "escaping link listed: {names:?}");
1431
1432 let rendered: Vec<String> = tt
1433 .for_tenant("acme")
1434 .get_template_names()
1435 .map(str::to_owned)
1436 .collect();
1437 assert!(!rendered.iter().any(|n| n == "peek.html"), "escaping link loaded: {rendered:?}");
1438 }
1439
1440 #[test]
1441 fn a_symlink_that_stays_inside_the_tenant_is_still_fine() {
1442 let s = Scratch::new();
1446 let tt = two_tenants(&s);
1447 std::os::unix::fs::symlink(s.0.join("t/acme/own.html"), s.0.join("t/acme/alias.html"))
1448 .expect("symlink");
1449 assert_eq!(tt.read_override("acme", "alias.html").as_deref(), Some("acme-own"));
1450 }
1451
1452 #[test]
1453 fn one_tenant_cannot_reach_another_by_name_alone() {
1454 let s = Scratch::new();
1456 let tt = two_tenants(&s);
1457 for name in ["../other/secret.html", "/../other/secret.html", "..%2Fother.html"] {
1458 assert!(
1459 tt.read_override("acme", name).is_none(),
1460 "{name:?} must not resolve",
1461 );
1462 }
1463 }
1464
1465 #[test]
1466 fn the_cache_is_bounded_and_evicts_the_least_recently_used() {
1467 let s = Scratch::new();
1468 for i in 0..4 {
1469 s.write(&format!("t{i}/page.html"), &format!("tenant-{i}"));
1470 }
1471 let tt = TenantTemplates::new(global(), &s.0)
1472 .with_reload(Reload::Never)
1473 .with_capacity(2);
1474 let _ = tt.for_tenant("t0");
1475 let _ = tt.for_tenant("t1");
1476 let _ = tt.for_tenant("t0"); let _ = tt.for_tenant("t2"); let cache = tt.cache.read().unwrap();
1480 assert_eq!(cache.len(), 2, "cache must stay bounded");
1481 assert!(cache.contains_key("t0"), "recently used survives");
1482 assert!(!cache.contains_key("t1"), "least recently used evicted");
1483 }
1484
1485 #[test]
1486 fn an_evicted_tenant_still_renders_correctly() {
1487 let s = Scratch::new();
1489 s.write("t0/page.html", "zero");
1490 s.write("t1/page.html", "one");
1491 let tt = TenantTemplates::new(global(), &s.0).with_capacity(1);
1492 assert_eq!(render(&tt.for_tenant("t0"), "page.html"), "zero");
1493 assert_eq!(render(&tt.for_tenant("t1"), "page.html"), "one");
1494 assert_eq!(render(&tt.for_tenant("t0"), "page.html"), "zero");
1495 }
1496
1497 #[test]
1500 fn a_reused_slug_does_not_inherit_the_old_overrides() {
1501 let s = Scratch::new();
1502 s.write("acme/page.html", "OLD-CUSTOMER");
1503 let tt = TenantTemplates::new(global(), &s.0);
1504
1505 assert_eq!(tt.claim("acme", "db-born-1").expect("claim"), Claim::Adopted);
1506 assert_eq!(tt.claim("acme", "db-born-1").expect("claim"), Claim::Owned);
1507 assert_eq!(render(&tt.for_tenant("acme"), "page.html"), "OLD-CUSTOMER");
1508
1509 match tt.claim("acme", "db-born-2").expect("claim") {
1511 Claim::MovedAside { previous_owner, to } => {
1512 assert_eq!(previous_owner, "db-born-1");
1513 assert!(to.join("page.html").is_file(), "kept, not deleted");
1514 }
1515 other => panic!("expected the old directory moved aside, got {other:?}"),
1516 }
1517 assert_eq!(
1518 render(&tt.for_tenant("acme"), "page.html"),
1519 "GLOBAL-BASE[global-page]",
1520 "the cached old instance is gone too"
1521 );
1522 assert_eq!(tt.claim("acme", "db-born-2").expect("claim"), Claim::NoOverrides);
1523 assert!(tt.tenant_dir(".orphaned").is_none(), "the aside directory is no tenant's");
1524 }
1525
1526 #[test]
1527 fn the_owner_marker_is_not_a_template() {
1528 let s = Scratch::new();
1529 s.write("acme/page.html", "MINE");
1530 let tt = TenantTemplates::new(global(), &s.0);
1531 tt.claim("acme", "db").expect("claim");
1532 assert_eq!(render(&tt.for_tenant("acme"), "page.html"), "MINE");
1533 assert!(tt.for_tenant("acme").get_template(OWNER_FILE).is_err());
1534 }
1535
1536 #[cfg(feature = "sqlite")]
1537 #[tokio::test]
1538 async fn database_birth_is_the_first_applied_migration() {
1539 let pool = rustango::sql::Pool::connect("sqlite::memory:").await.expect("pool");
1540 rustango::sql::raw_execute_pool(
1541 &pool,
1542 "CREATE TABLE __rustango_migrations__ (name TEXT PRIMARY KEY, applied_at TEXT NOT NULL)",
1543 Vec::new(),
1544 )
1545 .await
1546 .expect("ledger");
1547 assert_eq!(database_birth(&pool).await.expect("empty"), None);
1548 for (name, at) in [("0002_b", "2026-02-01T00:00:00+00:00"), ("0001_a", "2026-01-01T00:00:00+00:00")] {
1549 rustango::sql::raw_execute_pool(
1550 &pool,
1551 &format!("INSERT INTO __rustango_migrations__ VALUES ('{name}', '{at}')"),
1552 Vec::new(),
1553 )
1554 .await
1555 .expect("row");
1556 }
1557 assert_eq!(
1558 database_birth(&pool).await.expect("birth").as_deref(),
1559 Some("2026-01-01T00:00:00+00:00")
1560 );
1561 }
1562
1563 #[test]
1566 fn cached_serves_only_an_instance_not_due_a_check() {
1567 let s = Scratch::new();
1568 s.write("acme/page.html", "MINE");
1569 let never = TenantTemplates::new(global(), &s.0).with_reload(Reload::Never);
1570 assert!(never.cached("acme").is_none(), "nothing built yet");
1571 let built = never.for_tenant("acme");
1572 let hit = never.cached("acme").expect("cached after a build");
1573 assert!(Arc::ptr_eq(&built, &hit));
1574
1575 let always = TenantTemplates::new(global(), &s.0).with_reload(Reload::Always);
1576 let _ = always.for_tenant("acme");
1577 assert!(always.cached("acme").is_none(), "always due: re-check on the blocking pool");
1578 }
1579
1580 #[cfg(unix)]
1583 #[test]
1584 fn a_symlinked_subdirectory_creates_nothing_outside() {
1585 let s = Scratch::new();
1586 let outside = Scratch::new();
1587 std::fs::create_dir_all(s.0.join("acme")).unwrap();
1588 std::os::unix::fs::symlink(&outside.0, s.0.join("acme/evil")).unwrap();
1589 let tt = TenantTemplates::new(global(), &s.0);
1590 assert!(tt.write_override("acme", "evil/new/x.html", "x").is_err());
1591 assert!(!outside.0.join("new").exists(), "no directory was created outside");
1592 }
1593}