use std::path::PathBuf;
use std::sync::OnceLock;
use rustango::storage::registry::StorageRegistry;
use rustango::storage::{BoxedStorage, LocalStorage};
pub const DEFAULT_MEDIA_ROOT: &str = "./var/media";
pub const DISK: &str = "media";
static REGISTRY: OnceLock<StorageRegistry> = OnceLock::new();
static FALLBACK: OnceLock<BoxedStorage> = OnceLock::new();
pub fn install(registry: StorageRegistry) -> bool {
REGISTRY.set(registry).is_ok()
}
#[must_use]
pub fn tenant_disk_name(tenant_slug: &str) -> String {
format!("tenant:{tenant_slug}")
}
#[must_use]
pub fn disk_for(tenant_slug: &str) -> BoxedStorage {
if let Some(reg) = REGISTRY.get() {
if let Some(d) = reg.disk(&tenant_disk_name(tenant_slug)) {
return d;
}
if let Some(d) = reg.default_disk() {
return d;
}
}
local_fallback()
}
fn disk_name_for(reg: &StorageRegistry, tenant_slug: &str) -> Option<String> {
let own = tenant_disk_name(tenant_slug);
if reg.has(&own) {
return Some(own);
}
reg.default_name().map(str::to_owned)
}
fn local_fallback() -> BoxedStorage {
FALLBACK
.get_or_init(|| std::sync::Arc::new(LocalStorage::new(PathBuf::from(DEFAULT_MEDIA_ROOT))))
.clone()
}
#[must_use]
pub fn disk() -> BoxedStorage {
if let Some(reg) = REGISTRY.get() {
if let Some(d) = reg.default_disk() {
return d;
}
}
local_fallback()
}
#[must_use]
pub fn key(tenant_slug: &str, storage_key: &str) -> String {
format!("{tenant_slug}/{storage_key}")
}
#[must_use]
pub fn public_url(tenant_slug: &str, storage_key: &str) -> Option<String> {
let k = key(tenant_slug, storage_key);
if let Some(reg) = REGISTRY.get() {
if let Some(name) = disk_name_for(reg, tenant_slug) {
return reg.cdn_url(&name, &k);
}
}
disk_for(tenant_slug).url(&k)
}
#[must_use]
pub fn origin_url(tenant_slug: &str, storage_key: &str) -> Option<String> {
let k = key(tenant_slug, storage_key);
if let Some(reg) = REGISTRY.get() {
if let Some(name) = disk_name_for(reg, tenant_slug) {
return reg.origin_url(&name, &k);
}
}
disk_for(tenant_slug).url(&k)
}
pub fn install_from_env() -> Result<(), String> {
let backend = crate::config::var("MEDIA_BACKEND").unwrap_or_default();
let disk: BoxedStorage = match backend.as_str() {
"" | "local" => return Ok(()),
"memory" => {
tracing::warn!("media storage backend = in-memory (nothing hits disk)");
std::sync::Arc::new(rustango::storage::InMemoryStorage::default())
}
#[cfg(feature = "storage_s3")]
"s3" => {
use rustango::storage::s3::{S3Config, S3Credentials, S3Storage};
let req = |k: &str| {
crate::config::var(k).ok_or_else(|| format!("RCMS_MEDIA_BACKEND=s3 requires RCMS_{k}"))
};
let mut cfg = S3Config::new(req("S3_BUCKET")?, req("S3_REGION")?)
.with_path_style(crate::config::var("S3_PATH_STYLE").as_deref() != Some("false"));
cfg.endpoint = crate::config::var("S3_ENDPOINT");
let creds = S3Credentials::new(req("S3_ACCESS_KEY_ID")?, req("S3_SECRET_ACCESS_KEY")?);
tracing::info!(
bucket = %cfg.bucket, region = %cfg.region, endpoint = ?cfg.endpoint,
"media storage backend = s3",
);
std::sync::Arc::new(S3Storage::new(cfg, creds))
}
other => {
return Err(format!(
"unknown CMS_MEDIA_BACKEND={other:?} (expected local | memory | s3; \
`s3` also needs the rustango-cms `storage_s3` feature)",
))
}
};
let mut registry = StorageRegistry::new().set(DISK, disk).with_default(DISK);
if let Some(base) = crate::config::var("MEDIA_CDN_BASE") {
let base = base.trim_end_matches('/').to_owned();
if !base.is_empty() {
tracing::info!(cdn = %base, disk = DISK, "media CDN base configured");
registry = registry.cdn(DISK, base);
}
}
#[cfg(feature = "storage_s3")]
if backend == "s3" {
use rustango::storage::s3::{S3Config, S3Credentials, S3Storage};
let cdns = parse_pairs(&crate::config::var("MEDIA_TENANT_CDNS").unwrap_or_default());
for (slug, bucket) in
parse_pairs(&crate::config::var("MEDIA_TENANT_BUCKETS").unwrap_or_default())
{
let mut cfg = S3Config::new(bucket.clone(), crate::config::var("S3_REGION").unwrap_or_default())
.with_path_style(crate::config::var("S3_PATH_STYLE").as_deref() != Some("false"));
cfg.endpoint = crate::config::var("S3_ENDPOINT");
let creds = S3Credentials::new(
crate::config::var("S3_ACCESS_KEY_ID").unwrap_or_default(),
crate::config::var("S3_SECRET_ACCESS_KEY").unwrap_or_default(),
);
let tenant_disk: BoxedStorage = std::sync::Arc::new(S3Storage::new(cfg, creds));
registry = registry.set(tenant_disk_name(&slug), tenant_disk);
if let Some(base) = cdns.iter().find(|(s, _)| *s == slug).map(|(_, b)| b) {
registry = registry.cdn(tenant_disk_name(&slug), base.trim_end_matches('/').to_owned());
}
tracing::info!(tenant = %slug, %bucket, "media: dedicated bucket");
}
}
if install(registry) {
Ok(())
} else {
Err("a media storage registry was already installed; CMS_MEDIA_BACKEND was not applied".to_owned())
}
}
#[cfg(feature = "storage_s3")]
fn parse_pairs(raw: &str) -> Vec<(String, String)> {
raw.split(',')
.filter_map(|kv| {
let (k, v) = kv.split_once('=')?;
let (k, v) = (k.trim(), v.trim());
(!k.is_empty() && !v.is_empty()).then(|| (k.to_owned(), v.to_owned()))
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn key_is_tenant_prefixed() {
assert_eq!(key("acme", "ab12-photo.jpg"), "acme/ab12-photo.jpg");
assert_eq!(
key("acme", "renditions/ab12-w800.webp"),
"acme/renditions/ab12-w800.webp"
);
}
#[test]
fn key_matches_the_legacy_on_disk_layout() {
let k = key("acme", "scratch/ab12-upload.png");
let resolved = PathBuf::from(DEFAULT_MEDIA_ROOT).join(&k);
assert_eq!(
resolved,
PathBuf::from("./var/media/acme/scratch/ab12-upload.png")
);
}
#[test]
fn cdn_url_wins_over_the_backend_url_and_origin_bypasses_it() {
use rustango::storage::InMemoryStorage;
let mem: BoxedStorage = std::sync::Arc::new(InMemoryStorage::default());
let reg = StorageRegistry::new()
.set(DISK, mem)
.with_default(DISK)
.cdn(DISK, "https://cdn.example.com/media");
let k = key("acme", "renditions/ab12-w800.webp");
assert_eq!(
reg.cdn_url(DISK, &k).as_deref(),
Some("https://cdn.example.com/media/acme/renditions/ab12-w800.webp"),
);
assert_eq!(reg.origin_url(DISK, &k), None);
}
#[test]
fn a_tenant_disk_wins_over_the_default_and_keeps_the_slug_prefix() {
use rustango::storage::InMemoryStorage;
let shared: BoxedStorage = std::sync::Arc::new(InMemoryStorage::default());
let acme: BoxedStorage = std::sync::Arc::new(InMemoryStorage::default());
let reg = StorageRegistry::new()
.set(DISK, shared)
.with_default(DISK)
.cdn(DISK, "https://cdn.shared.example/media")
.set("tenant:acme", acme)
.cdn("tenant:acme", "https://cdn.acme.example/media");
assert_eq!(disk_name_for(®, "acme").as_deref(), Some("tenant:acme"));
assert_eq!(
reg.cdn_url("tenant:acme", &key("acme", "photo.jpg")).as_deref(),
Some("https://cdn.acme.example/media/acme/photo.jpg"),
);
assert_eq!(disk_name_for(®, "globex").as_deref(), Some(DISK));
assert_eq!(
reg.cdn_url(DISK, &key("globex", "photo.jpg")).as_deref(),
Some("https://cdn.shared.example/media/globex/photo.jpg"),
);
}
#[test]
fn a_slug_cannot_select_a_host_disk() {
use rustango::storage::InMemoryStorage;
let shared: BoxedStorage = std::sync::Arc::new(InMemoryStorage::default());
let private: BoxedStorage = std::sync::Arc::new(InMemoryStorage::default());
let reg = StorageRegistry::new()
.set(DISK, shared)
.with_default(DISK)
.set("private", private);
assert_eq!(disk_name_for(®, "private").as_deref(), Some(DISK));
}
#[cfg(feature = "storage_s3")]
#[test]
fn tenant_pair_lists_skip_junk_rather_than_failing_boot() {
assert_eq!(
parse_pairs("acme=acme-media, globex = globex-media"),
vec![
("acme".to_owned(), "acme-media".to_owned()),
("globex".to_owned(), "globex-media".to_owned()),
],
);
assert_eq!(
parse_pairs("acme=b,,broken,=x,y="),
vec![("acme".to_owned(), "b".to_owned())]
);
assert!(parse_pairs("").is_empty());
}
#[test]
fn no_cdn_configured_falls_back_to_the_backend_url() {
use rustango::storage::InMemoryStorage;
let mem: BoxedStorage = std::sync::Arc::new(InMemoryStorage::default());
let reg = StorageRegistry::new().set(DISK, mem).with_default(DISK);
assert_eq!(reg.cdn_url(DISK, "acme/x.png"), None);
}
#[test]
fn disk_defaults_to_local_without_install() {
assert!(disk().url("acme/x.png").is_none());
}
}