use crate::log_err::LogErr as _;
use std::sync::Arc;
use axum::extract::{Path, Query};
use axum::http::request::Parts;
use axum::http::{header, HeaderValue, StatusCode};
use axum::response::{IntoResponse, Response};
use axum::routing::get;
use axum::Router;
use rustango::core::Column as _;
use rustango::extractors::TenantContext;
use rustango::sql::{Auto, FetcherPool as _};
use rustango::tenancy::{DefaultTenantDb, OrgResolver as _};
use crate::media::Media;
use crate::rendition::{apply, MediaRendition};
pub struct TenantLite {
pub org: rustango::tenancy::Org,
pool: rustango::sql::Pool,
}
impl<S> axum::extract::FromRequestParts<S> for TenantLite
where
S: Send + Sync,
{
type Rejection = (StatusCode, &'static str);
async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
let ctx = parts
.extensions
.get::<Arc<TenantContext<DefaultTenantDb>>>()
.cloned()
.ok_or((StatusCode::INTERNAL_SERVER_ERROR, "tenant context missing"))?;
let org = ctx
.resolver
.resolve(parts, &ctx.pools.registry_pool())
.await
.map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "tenant resolve failed"))?
.ok_or((StatusCode::NOT_FOUND, "tenant not found"))?;
let pool = ctx
.pools
.scoped_pool_dyn(&org)
.await
.map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "tenant pool unavailable"))?;
Ok(TenantLite { org, pool })
}
}
impl TenantLite {
pub fn pool(&self) -> &rustango::sql::Pool {
&self.pool
}
}
pub fn router() -> Router {
Router::new()
.route("/__media__/raw/{media_id}", get(serve_raw))
.route("/__media__/{filter_spec}/{media_id}", get(serve))
}
async fn serve_raw(
tenant: TenantLite,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
rustango::tenancy::member_auth::CurrentMember(member): rustango::tenancy::member_auth::CurrentMember,
Path(media_id): Path<i64>,
) -> Response {
let media: Media = match Media::objects()
.where_(Media::id.eq(media_id))
.fetch(tenant.pool())
.await
{
Ok(v) => match v.into_iter().next() {
Some(m) => m,
None => return (StatusCode::NOT_FOUND, "media not found").into_response(),
},
Err(e) => {
tracing::error!(error = %e, "media lookup failed");
return (StatusCode::INTERNAL_SERVER_ERROR, "media lookup failed").into_response();
}
};
let viewer = member.as_ref().or(session_user.as_ref());
let restricted = match check_collection_restriction(&tenant, &media, viewer).await {
Ok(r) => r,
Err(resp) => return resp,
};
let bytes = match crate::media_storage::disk_for(&tenant.org.slug)
.load(&crate::media_storage::key(
&tenant.org.slug,
&media.storage_key,
))
.await
{
Ok(b) => b,
Err(_) => {
return (StatusCode::NOT_FOUND, "original file missing in storage").into_response()
}
};
let mut resp = bytes.into_response();
let headers = resp.headers_mut();
set_media_cache(headers, restricted, "public, max-age=3600");
harden_media_headers(headers, &media.mime, &media.filename);
resp
}
#[derive(Debug, PartialEq, Eq)]
enum MediaDisplay {
Raster,
Svg,
Viewer,
Download,
}
fn media_display(mime: &str) -> MediaDisplay {
let mime = mime.split(';').next().unwrap_or("").trim().to_ascii_lowercase();
if mime == "image/svg+xml" {
MediaDisplay::Svg
} else if mime.starts_with("image/") {
MediaDisplay::Raster
} else if mime == "application/pdf"
|| mime == "text/plain"
|| mime.starts_with("video/")
|| mime.starts_with("audio/")
{
MediaDisplay::Viewer
} else {
MediaDisplay::Download
}
}
fn harden_media_headers(headers: &mut axum::http::HeaderMap, mime: &str, filename: &str) {
let display = media_display(mime);
let content_type = match display {
MediaDisplay::Svg => HeaderValue::from_static("image/svg+xml"),
MediaDisplay::Download => HeaderValue::from_static("application/octet-stream"),
MediaDisplay::Raster | MediaDisplay::Viewer => HeaderValue::from_str(mime)
.unwrap_or_else(|_| HeaderValue::from_static("application/octet-stream")),
};
headers.insert(header::CONTENT_TYPE, content_type);
headers.insert(
header::X_CONTENT_TYPE_OPTIONS,
HeaderValue::from_static("nosniff"),
);
match display {
MediaDisplay::Raster => {}
MediaDisplay::Svg => {
headers.insert(
header::CONTENT_SECURITY_POLICY,
HeaderValue::from_static(
"default-src 'none'; style-src 'unsafe-inline'; img-src data:; sandbox",
),
);
}
MediaDisplay::Viewer | MediaDisplay::Download => {
headers.insert(
header::CONTENT_SECURITY_POLICY,
HeaderValue::from_static("sandbox"),
);
let disposition = if display == MediaDisplay::Viewer {
"inline"
} else {
"attachment"
};
let name: String = filename
.chars()
.filter(|c| !c.is_control() && *c != '"' && *c != '\\')
.collect();
if let Ok(v) = HeaderValue::from_str(&format!("{disposition}; filename=\"{name}\"")) {
headers.insert(header::CONTENT_DISPOSITION, v);
}
}
}
}
async fn check_collection_restriction(
tenant: &TenantLite,
media: &Media,
viewer: Option<&rustango::tenancy::auth::User>,
) -> Result<bool, Response> {
let Some(collection_id) = media.collection_id else {
return Ok(false);
};
match crate::collection_view_restriction::effective_for_collection(tenant.pool(), collection_id)
.await
{
Ok(Some(r)) => match r.parsed_kind() {
Some(crate::view_restriction::RestrictionKind::Login)
| Some(crate::view_restriction::RestrictionKind::Password) => {
if viewer.is_none() {
return Err((
StatusCode::UNAUTHORIZED,
"media collection requires authentication",
)
.into_response());
}
Ok(true)
}
Some(crate::view_restriction::RestrictionKind::Groups) => {
let Some(user) = viewer else {
return Err((
StatusCode::UNAUTHORIZED,
"media collection requires authentication",
)
.into_response());
};
if !user.is_superuser
&& !user_in_any_role(tenant.pool(), user, &r.parsed_groups()).await
{
return Err((StatusCode::FORBIDDEN, "forbidden").into_response());
}
Ok(true)
}
Some(crate::view_restriction::RestrictionKind::Permission) => {
let Some(user) = viewer else {
return Err((
StatusCode::UNAUTHORIZED,
"media collection requires authentication",
)
.into_response());
};
let uid = user.id.get().copied().unwrap_or_default();
if !crate::view_restriction_guard::viewer_has_any_codename(
tenant.pool(),
uid,
&r.parsed_codenames(),
)
.await
{
return Err((StatusCode::FORBIDDEN, "forbidden").into_response());
}
Ok(true)
}
None => Err((StatusCode::FORBIDDEN, "forbidden").into_response()),
},
Ok(None) => Ok(false),
Err(e) => {
tracing::warn!(
target: "rustango_cms::rendition_route",
media_id = ?media.id, error = %e,
"collection view-restriction lookup failed; denying"
);
Err((StatusCode::SERVICE_UNAVAILABLE, "try again").into_response())
}
}
}
#[derive(serde::Deserialize, Default)]
struct RenditionQuery {
#[serde(default)]
s: Option<String>,
}
async fn serve(
tenant: TenantLite,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
rustango::tenancy::member_auth::CurrentMember(member): rustango::tenancy::member_auth::CurrentMember,
Path((filter_spec, media_id)): Path<(String, i64)>,
Query(query): Query<RenditionQuery>,
) -> Response {
let pipeline = match crate::rendition::FilterPipeline::parse(&filter_spec) {
Ok(o) => o,
Err(e) => {
return (StatusCode::BAD_REQUEST, e.to_string()).into_response();
}
};
let canonical_spec = pipeline.canonical();
let op = pipeline.geometric;
if !crate::rendition::verify_rendition_sig(&canonical_spec, media_id, query.s.as_deref()) {
return (
StatusCode::FORBIDDEN,
"invalid or missing rendition signature",
)
.into_response();
}
let media: Media = match Media::objects()
.where_(Media::id.eq(media_id))
.fetch(tenant.pool())
.await
{
Ok(v) => match v.into_iter().next() {
Some(m) => m,
None => return (StatusCode::NOT_FOUND, "media not found").into_response(),
},
Err(e) => {
tracing::error!(error = %e, "media lookup failed");
return (StatusCode::INTERNAL_SERVER_ERROR, "media lookup failed").into_response();
}
};
if media.kind != "image" {
return (
StatusCode::BAD_REQUEST,
"media is not an image — renditions only apply to images",
)
.into_response();
}
let viewer = member.as_ref().or(session_user.as_ref());
if media.mime == "image/svg+xml" {
let restricted = match check_collection_restriction(&tenant, &media, viewer).await {
Ok(r) => r,
Err(resp) => return resp,
};
let bytes = match crate::media_storage::disk_for(&tenant.org.slug)
.load(&crate::media_storage::key(
&tenant.org.slug,
&media.storage_key,
))
.await
{
Ok(b) => b,
Err(e) => {
tracing::error!(
target: "rustango_cms::rendition_route",
media_id, error = %e,
"svg source bytes unreadable"
);
return (StatusCode::INTERNAL_SERVER_ERROR, "svg source unreadable")
.into_response();
}
};
let _ = (op, &canonical_spec);
let mut resp = bytes.into_response();
let headers = resp.headers_mut();
set_media_cache(headers, restricted, "public, max-age=31536000, immutable");
harden_media_headers(headers, "image/svg+xml", &media.filename);
return resp;
}
let restricted = match check_collection_restriction(&tenant, &media, viewer).await {
Ok(r) => r,
Err(resp) => return resp,
};
let rendition_lookup: Result<Vec<MediaRendition>, _> = MediaRendition::objects()
.where_(MediaRendition::content_hash.eq(media.content_hash.clone()))
.where_(MediaRendition::filter_spec.eq(canonical_spec.clone()))
.fetch(tenant.pool())
.await;
let existing = match rendition_lookup {
Ok(v) => v.into_iter().next(),
Err(e) => {
tracing::error!(error = %e, "rendition lookup failed");
return (StatusCode::INTERNAL_SERVER_ERROR, "rendition lookup failed").into_response();
}
};
let (rendition, bytes) = match existing {
Some(r) => {
match crate::media_storage::disk_for(&tenant.org.slug)
.load(&crate::media_storage::key(&tenant.org.slug, &r.storage_key))
.await
{
Ok(b) => (r, b),
Err(_) => {
match generate_once(&tenant, &media, &pipeline, &canonical_spec).await {
Ok(out) => out,
Err(e) => {
tracing::error!(error = %e, "rendition regenerate failed");
return (
StatusCode::INTERNAL_SERVER_ERROR,
"rendition regenerate failed",
)
.into_response();
}
}
}
}
}
None => match generate_once(&tenant, &media, &pipeline, &canonical_spec).await {
Ok(out) => out,
Err(e) => {
tracing::error!(error = %e, "rendition generate failed");
return (StatusCode::INTERNAL_SERVER_ERROR, format!("generate: {e}"))
.into_response();
}
},
};
let rendition_mime = rendition.mime.clone();
{
let mut r = rendition;
r.last_used_at = chrono::Utc::now();
r.save_pool(tenant.pool()).await.log_warn("rendition last_used_at not bumped");
}
let mut resp = bytes.into_response();
let headers = resp.headers_mut();
if let Ok(v) = HeaderValue::from_str(&rendition_mime) {
headers.insert(header::CONTENT_TYPE, v);
}
set_media_cache(headers, restricted, "public, max-age=31536000, immutable");
resp
}
fn set_media_cache(headers: &mut axum::http::HeaderMap, restricted: bool, public: &'static str) {
if restricted {
headers.insert(header::CACHE_CONTROL, HeaderValue::from_static("private, no-store"));
headers.insert(header::VARY, HeaderValue::from_static("Cookie"));
} else {
headers.insert(header::CACHE_CONTROL, HeaderValue::from_static(public));
}
}
static GENERATING: std::sync::Mutex<
Option<std::collections::HashMap<String, std::sync::Weak<rustango::__private_runtime::tokio::sync::Mutex<()>>>>,
> = std::sync::Mutex::new(None);
fn generation_lock(key: String) -> Arc<rustango::__private_runtime::tokio::sync::Mutex<()>> {
let mut g = GENERATING.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
let map = g.get_or_insert_with(Default::default);
if let Some(lock) = map.get(&key).and_then(std::sync::Weak::upgrade) {
return lock;
}
map.retain(|_, w| w.strong_count() > 0);
let lock = Arc::new(rustango::__private_runtime::tokio::sync::Mutex::new(()));
map.insert(key, Arc::downgrade(&lock));
lock
}
fn decode_permits() -> &'static rustango::__private_runtime::tokio::sync::Semaphore {
static PERMITS: std::sync::OnceLock<rustango::__private_runtime::tokio::sync::Semaphore> =
std::sync::OnceLock::new();
PERMITS.get_or_init(|| {
let n = std::thread::available_parallelism().map_or(2, std::num::NonZeroUsize::get);
rustango::__private_runtime::tokio::sync::Semaphore::new(n.max(2))
})
}
async fn generate_once(
tenant: &TenantLite,
media: &Media,
pipeline: &crate::rendition::FilterPipeline,
canonical_spec: &str,
) -> Result<(MediaRendition, Vec<u8>), String> {
let key = format!("{}\u{0}{}\u{0}{canonical_spec}", tenant.org.slug, media.content_hash);
let lock = generation_lock(key);
let _held = lock.lock().await;
let done: Option<MediaRendition> = MediaRendition::objects()
.where_(MediaRendition::content_hash.eq(media.content_hash.clone()))
.where_(MediaRendition::filter_spec.eq(canonical_spec.to_owned()))
.first(tenant.pool())
.await
.map_err(|e| format!("rendition lookup: {e}"))?;
if let Some(r) = done {
if let Ok(bytes) = crate::media_storage::disk_for(&tenant.org.slug)
.load(&crate::media_storage::key(&tenant.org.slug, &r.storage_key))
.await
{
return Ok((r, bytes));
}
}
let _permit = decode_permits()
.acquire()
.await
.map_err(|e| format!("rendition decode permit: {e}"))?;
generate(tenant, media, pipeline, canonical_spec).await
}
async fn generate(
tenant: &TenantLite,
media: &Media,
pipeline: &crate::rendition::FilterPipeline,
canonical_spec: &str,
) -> Result<(MediaRendition, Vec<u8>), String> {
let src_key = crate::media_storage::key(&tenant.org.slug, &media.storage_key);
let src_bytes = crate::media_storage::disk_for(&tenant.org.slug)
.load(&src_key)
.await
.map_err(|e| format!("read original {src_key}: {e}"))?;
let pipeline = *pipeline; let focal = match (media.focal_point_x, media.focal_point_y) {
(Some(x), Some(y)) => Some((x, y)),
_ => None,
};
let media_mime = media.mime.clone();
let content_hash = media.content_hash.clone();
let canonical_spec_owned = canonical_spec.to_owned();
struct Blocking {
out_bytes: Vec<u8>,
out_mime: String,
storage_key: String,
width: i32,
height: i32,
}
let blocking: Result<Blocking, String> =
rustango::__private_runtime::tokio::task::spawn_blocking(move || {
let img =
image::load_from_memory(&src_bytes).map_err(|e| format!("decode source: {e}"))?;
let resized = apply(&img, pipeline.geometric, focal);
let (w, h) = (resized.width(), resized.height());
let (out_bytes, out_mime, ext) =
crate::rendition::encode(&resized, &pipeline.encoding, &media_mime)?;
let safe_spec = canonical_spec_owned.replace('|', "_");
let storage_key = format!(
"renditions/{}-{}.{ext}",
&content_hash[..32.min(content_hash.len())],
safe_spec
);
Ok(Blocking {
out_bytes,
out_mime,
storage_key,
width: w as i32,
height: h as i32,
})
})
.await
.map_err(|e| format!("rendition spawn_blocking joined error: {e}"))?;
let b = blocking?;
crate::media_storage::disk_for(&tenant.org.slug)
.save(
&crate::media_storage::key(&tenant.org.slug, &b.storage_key),
&b.out_bytes,
)
.await
.map_err(|e| format!("write rendition: {e}"))?;
let mut row = MediaRendition {
id: Auto::Unset,
media_id: media.id.get().copied().unwrap_or_default(),
content_hash: media.content_hash.clone(),
filter_spec: canonical_spec.to_owned(),
width: b.width,
height: b.height,
mime: b.out_mime,
storage_key: b.storage_key,
size: b.out_bytes.len() as i64,
last_used_at: chrono::Utc::now(),
created_at: Auto::Unset,
};
row.insert_pool(tenant.pool())
.await
.map_err(|e| format!("insert rendition: {e}"))?;
Ok((row, b.out_bytes))
}
pub async fn gc_older_than(
pool: &rustango::sql::Pool,
tenant_slug: &str,
cutoff: chrono::DateTime<chrono::Utc>,
) -> Result<usize, rustango::sql::ExecError> {
use rustango::core::Column as _;
let stale: Vec<MediaRendition> = MediaRendition::objects()
.where_(MediaRendition::last_used_at.lt(cutoff))
.fetch(pool)
.await?;
let mut removed = 0usize;
for r in stale {
crate::media_storage::disk_for(tenant_slug)
.delete(&crate::media_storage::key(tenant_slug, &r.storage_key))
.await
.log_warn("stored file not deleted; the blob is orphaned");
r.delete_pool(pool).await?;
removed += 1;
}
Ok(removed)
}
async fn user_in_any_role(
pool: &rustango::sql::Pool,
user: &rustango::tenancy::auth::User,
allowed: &[i64],
) -> bool {
if allowed.is_empty() {
return false;
}
let Some(user_id) = user.id.get().copied() else {
return false;
};
use rustango::sql::FetcherPool as _;
let memberships: Vec<rustango::tenancy::permissions::UserRole> =
match rustango::tenancy::permissions::UserRole::objects()
.where_(rustango::tenancy::permissions::UserRole::user_id.eq(user_id))
.fetch(pool)
.await
{
Ok(v) => v,
Err(_) => return false,
};
let mine: std::collections::HashSet<i64> = memberships.iter().map(|m| m.role_id).collect();
allowed.iter().any(|r| mine.contains(r))
}
#[cfg(test)]
mod tests {
use super::*;
fn served(mime: &str, filename: &str) -> axum::http::HeaderMap {
let mut h = axum::http::HeaderMap::new();
harden_media_headers(&mut h, mime, filename);
h
}
fn get<'a>(h: &'a axum::http::HeaderMap, name: header::HeaderName) -> &'a str {
h.get(name).and_then(|v| v.to_str().ok()).unwrap_or("")
}
#[test]
fn active_uploads_download_sandboxed_and_unsniffed() {
for mime in ["text/html", "application/xhtml+xml", "text/xml", "application/javascript", "TEXT/HTML; charset=utf-8"] {
let h = served(mime, "x.html");
assert_eq!(get(&h, header::CONTENT_TYPE), "application/octet-stream", "{mime}");
assert!(get(&h, header::CONTENT_DISPOSITION).starts_with("attachment;"), "{mime}");
assert_eq!(get(&h, header::CONTENT_SECURITY_POLICY), "sandbox", "{mime}");
assert_eq!(get(&h, header::X_CONTENT_TYPE_OPTIONS), "nosniff", "{mime}");
}
}
#[test]
fn svg_stays_inline_but_cannot_run_script() {
let h = served("image/svg+xml", "logo.svg");
assert_eq!(get(&h, header::CONTENT_TYPE), "image/svg+xml");
assert!(h.get(header::CONTENT_DISPOSITION).is_none());
let csp = get(&h, header::CONTENT_SECURITY_POLICY);
assert!(csp.contains("default-src 'none'") && csp.contains("sandbox"), "{csp}");
}
#[test]
fn raster_and_viewer_types_stay_inline() {
let h = served("image/png", "a.png");
assert_eq!(get(&h, header::CONTENT_TYPE), "image/png");
assert!(h.get(header::CONTENT_SECURITY_POLICY).is_none());
let h = served("application/pdf", "a \"b\".pdf");
assert_eq!(get(&h, header::CONTENT_DISPOSITION), "inline; filename=\"a b.pdf\"");
assert_eq!(get(&h, header::CONTENT_SECURITY_POLICY), "sandbox");
}
}
#[cfg(test)]
mod single_flight_tests {
use super::{decode_permits, generation_lock, GENERATING};
use std::sync::Arc;
#[test]
fn one_rendition_key_shares_one_lock_while_in_flight() {
let a = generation_lock("t\0hash\0fill-10x10".to_owned());
let b = generation_lock("t\0hash\0fill-10x10".to_owned());
assert!(Arc::ptr_eq(&a, &b), "concurrent misses wait on one generation");
let other = generation_lock("t\0hash\0fill-20x20".to_owned());
assert!(!Arc::ptr_eq(&a, &other), "another spec generates independently");
drop((a, b, other));
let _fresh = generation_lock("t\0hash\0unrelated".to_owned());
let g = GENERATING.lock().expect("lock");
let map = g.as_ref().expect("map");
assert!(!map.contains_key("t\0hash\0fill-10x10"), "finished keys are pruned");
}
#[test]
fn decodes_are_capped() {
let n = decode_permits().available_permits();
assert!(n >= 2, "at least two decodes may run: {n}");
assert!(n <= 1024, "bounded well below the blocking pool: {n}");
}
}
#[cfg(test)]
mod media_cache_tests {
use super::set_media_cache;
use axum::http::{header, HeaderMap};
#[test]
fn restricted_media_never_reaches_a_shared_cache() {
let mut h = HeaderMap::new();
set_media_cache(&mut h, true, "public, max-age=31536000, immutable");
assert_eq!(h[header::CACHE_CONTROL], "private, no-store");
assert_eq!(h[header::VARY], "Cookie");
let mut h = HeaderMap::new();
set_media_cache(&mut h, false, "public, max-age=3600");
assert_eq!(h[header::CACHE_CONTROL], "public, max-age=3600");
assert!(h.get(header::VARY).is_none());
}
}