diff --git a/Cargo.lock b/Cargo.lock index a91f345..9a1b6f2 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1418,7 +1418,7 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c" [[package]] name = "furumusic" -version = "0.1.22" +version = "0.2.1" dependencies = [ "anyhow", "async-trait", diff --git a/Cargo.toml b/Cargo.toml index 578600d..e93877c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "furumusic" -version = "0.2.0" +version = "0.2.1" edition = "2024" description = "Reusable web-app boilerplate: auth, OIDC/SSO, admin panel, user management, i18n, PostgreSQL" diff --git a/src/agent/cover_art.rs b/src/agent/cover_art.rs index c0617bc..51990da 100644 --- a/src/agent/cover_art.rs +++ b/src/agent/cover_art.rs @@ -323,27 +323,50 @@ pub async fn save_cover_to_storage( let hash = hash_image(&cover.data); // Check if we already have this exact image in the DB - let existing: Option<(i64,)> = sqlx::query_as( - "SELECT id FROM furumusic__media_file WHERE sha256_hash = $1 AND file_type = 'cover_art' LIMIT 1", + let existing: Option<(i64, String)> = sqlx::query_as( + "SELECT id, file_path FROM furumusic__media_file WHERE sha256_hash = $1 AND file_type = 'cover_art' LIMIT 1", ) .bind(&hash) .fetch_optional(pool) .await?; - if let Some((id,)) = existing { - if let Some((file_path,)) = sqlx::query_as::<_, (String,)>( - "SELECT file_path FROM furumusic__media_file WHERE id = $1", - ) - .bind(id) - .fetch_optional(pool) - .await? - { - let path = crate::media_paths::resolve_media_file_path(storage_dir, &file_path); + if let Some((id, file_path)) = existing { + let path = crate::media_paths::resolve_media_file_path(storage_dir, &file_path); + let is_inside_storage = crate::media_paths::path_for_root(storage_dir, &path).is_some(); + if !is_inside_storage { + tracing::warn!( + media_file_id = id, + path = %path.display(), + "Ignoring duplicate cover hash whose stored file is outside agent_storage_dir" + ); + } else if !path.exists() { + if let Some(parent) = path.parent() { + tokio::fs::create_dir_all(parent).await?; + } + match tokio::fs::write(&path, &cover.data).await { + Ok(()) => { + tracing::info!( + media_file_id = id, + path = %path.display(), + "Restored missing cover file for existing MediaFile" + ); + } + Err(err) => { + tracing::warn!( + media_file_id = id, + path = %path.display(), + error = %err, + "Failed to restore missing cover file for existing MediaFile; creating a new cover file" + ); + } + } + } + if is_inside_storage && path.exists() { if let Err(err) = crate::agent::cover_variants::ensure_cover_variants(&path).await { tracing::warn!(media_file_id = id, error = %err, "Failed to generate cover variants"); } + return Ok(id); } - return Ok(id); } let ext = extension_for_mime(&cover.mime_type); @@ -352,7 +375,9 @@ pub async fn save_cover_to_storage( let artist_dir = sanitize_dir_name(artist_name); let album_dir = sanitize_dir_name(release_title); - let dest_dir = Path::new(storage_dir).join(&artist_dir).join(&album_dir); + let dest_dir = crate::media_paths::resolve_config_path_buf(storage_dir) + .join(&artist_dir) + .join(&album_dir); tokio::fs::create_dir_all(&dest_dir).await?; let dest_path = dest_dir.join(&filename); diff --git a/src/config.rs b/src/config.rs index aa1e6c6..e3dc22a 100644 --- a/src/config.rs +++ b/src/config.rs @@ -416,6 +416,13 @@ impl AppConfig { #[cfg(test)] mod tests { use super::*; + use std::sync::{Mutex, MutexGuard}; + + static ENV_LOCK: Mutex<()> = Mutex::new(()); + + fn lock_env() -> MutexGuard<'static, ()> { + ENV_LOCK.lock().unwrap_or_else(|err| err.into_inner()) + } #[test] fn defaults_are_sane() { @@ -439,20 +446,14 @@ mod tests { } #[test] - fn maps_foreign_windows_media_paths_to_working_dir() { - let expected = std::env::current_dir() - .unwrap() - .join("media") - .join("uploads") - .to_string_lossy() - .to_string(); + fn keeps_absolute_windows_media_paths() { assert_eq!( crate::media_paths::resolve_config_path(r"C:\Users\ab\repos\furumusic\media\uploads"), - expected + "C:/Users/ab/repos/furumusic/media/uploads" ); } - // SAFETY: tests run with --test-threads=1 so no concurrent env access. + // SAFETY: environment-mutating tests take ENV_LOCK before changing vars. unsafe fn set(k: &str, v: &str) { unsafe { std::env::set_var(k, v) }; } @@ -462,6 +463,7 @@ mod tests { #[test] fn env_override_string_field() { + let _guard = lock_env(); unsafe { set("FURU_OIDC_ISSUER", "https://example.com"); } @@ -474,6 +476,7 @@ mod tests { #[test] fn env_override_bool_field() { + let _guard = lock_env(); unsafe { set("FURU_AUTH_SSO_ENABLED", "true"); } @@ -486,6 +489,7 @@ mod tests { #[test] fn source_tracking_env() { + let _guard = lock_env(); unsafe { set("FURU_OIDC_ISSUER", "https://tracked.example.com"); } diff --git a/src/jobs/artwork_backfill.rs b/src/jobs/artwork_backfill.rs index fa23504..18b152d 100644 --- a/src/jobs/artwork_backfill.rs +++ b/src/jobs/artwork_backfill.rs @@ -1,7 +1,10 @@ use std::path::PathBuf; use reqwest::Client; -use serde::Deserialize; +use serde::{ + Deserialize, + de::{self, DeserializeOwned}, +}; use crate::agent::cover_art::{self, CoverImage, CoverSource}; use crate::agent::cover_variants; @@ -26,6 +29,13 @@ struct ArtistCandidate { name: String, } +#[derive(Debug, sqlx::FromRow)] +struct ArtworkRefCandidate { + entity_id: i64, + media_file_id: i64, + file_path: Option, +} + #[derive(Debug, Deserialize)] struct LastfmAlbumResponse { album: Option, @@ -40,6 +50,24 @@ struct LastfmArtistResponse { message: Option, } +#[derive(Debug, Deserialize)] +struct LastfmTopAlbumsResponse { + topalbums: Option, + error: Option, + message: Option, +} + +#[derive(Debug, Deserialize)] +struct LastfmTopAlbumsContainer { + #[serde(default, deserialize_with = "deserialize_one_or_many")] + album: Vec, +} + +#[derive(Debug, Deserialize)] +struct LastfmTopAlbum { + image: Option>, +} + #[derive(Debug, Deserialize)] struct LastfmImageContainer { image: Option>, @@ -54,6 +82,9 @@ struct LastfmImage { #[derive(Default)] struct ArtworkStats { + broken_release_refs_cleared: u64, + broken_track_refs_cleared: u64, + broken_artist_refs_cleared: u64, release_local_assigned: u64, release_lastfm_assigned: u64, release_lastfm_not_found: u64, @@ -108,6 +139,7 @@ impl Job for ArtworkBackfillJob { log.info("Media path normalization pass: all media file paths are already relative"); } + repair_missing_artwork_refs(ctx, log, storage_dir, &mut stats).await?; backfill_release_local(ctx, log, storage_dir, &mut stats).await?; let api_key = ctx.config.lastfm_api_key.trim(); @@ -118,10 +150,14 @@ impl Job for ArtworkBackfillJob { backfill_artist_lastfm(ctx, log, storage_dir, api_key, &client, &mut stats).await?; } + backfill_artist_album_fallbacks(ctx, log, &mut stats).await?; repair_cover_variants(ctx, log, storage_dir, &mut stats).await?; log.info(&format!( - "Artwork backfill complete: release_local_assigned={}, release_lastfm_assigned={}, release_lastfm_not_found={}, release_skipped_no_audio={}, artist_lastfm_assigned={}, artist_lastfm_not_found={}, artist_album_fallback_assigned={}, variants_created={}, variants_unchanged={}, variants_missing_original={}, failed={}", + "Artwork backfill complete: broken_release_refs_cleared={}, broken_track_refs_cleared={}, broken_artist_refs_cleared={}, release_local_assigned={}, release_lastfm_assigned={}, release_lastfm_not_found={}, release_skipped_no_audio={}, artist_lastfm_assigned={}, artist_lastfm_not_found={}, artist_album_fallback_assigned={}, variants_created={}, variants_unchanged={}, variants_missing_original={}, failed={}", + stats.broken_release_refs_cleared, + stats.broken_track_refs_cleared, + stats.broken_artist_refs_cleared, stats.release_local_assigned, stats.release_lastfm_assigned, stats.release_lastfm_not_found, @@ -138,6 +174,188 @@ impl Job for ArtworkBackfillJob { } } +async fn repair_missing_artwork_refs( + ctx: &JobContext, + log: &mut JobLog, + storage_dir: &str, + stats: &mut ArtworkStats, +) -> anyhow::Result<()> { + repair_missing_release_cover_refs(ctx, log, storage_dir, stats).await?; + repair_missing_track_cover_refs(ctx, log, storage_dir, stats).await?; + repair_missing_artist_image_refs(ctx, log, storage_dir, stats).await?; + Ok(()) +} + +async fn repair_missing_release_cover_refs( + ctx: &JobContext, + log: &mut JobLog, + storage_dir: &str, + stats: &mut ArtworkStats, +) -> anyhow::Result<()> { + let rows = sqlx::query_as::<_, ArtworkRefCandidate>( + r#"SELECT r.id AS entity_id, + r.cover_file_id AS media_file_id, + mf.file_path::text AS file_path + FROM furumusic__release r + LEFT JOIN furumusic__media_file mf ON mf.id = r.cover_file_id + WHERE r.cover_file_id IS NOT NULL + AND r.is_hidden = false + ORDER BY r.id"#, + ) + .fetch_all(&ctx.pool) + .await?; + + for row in rows { + if artwork_ref_exists(storage_dir, row.file_path.as_deref()) { + continue; + } + + let result = sqlx::query( + r#"UPDATE furumusic__release + SET cover_file_id = NULL, + updated_at = $3 + WHERE id = $1 + AND cover_file_id = $2"#, + ) + .bind(row.entity_id) + .bind(row.media_file_id) + .bind(now_iso()) + .execute(&ctx.pool) + .await?; + + if result.rows_affected() > 0 { + reset_lookup_state(&ctx.pool, "release", row.entity_id).await?; + stats.broken_release_refs_cleared += 1; + log.warn(&format!( + "Release {}: cleared missing cover reference media_file_id={}{}", + row.entity_id, + row.media_file_id, + artwork_ref_location(storage_dir, row.file_path.as_deref()) + )); + } + } + + Ok(()) +} + +async fn repair_missing_track_cover_refs( + ctx: &JobContext, + log: &mut JobLog, + storage_dir: &str, + stats: &mut ArtworkStats, +) -> anyhow::Result<()> { + let rows = sqlx::query_as::<_, ArtworkRefCandidate>( + r#"SELECT t.id AS entity_id, + t.cover_file_id AS media_file_id, + mf.file_path::text AS file_path + FROM furumusic__track t + LEFT JOIN furumusic__media_file mf ON mf.id = t.cover_file_id + WHERE t.cover_file_id IS NOT NULL + AND t.is_hidden = false + ORDER BY t.id"#, + ) + .fetch_all(&ctx.pool) + .await?; + + for row in rows { + if artwork_ref_exists(storage_dir, row.file_path.as_deref()) { + continue; + } + + let result = sqlx::query( + r#"UPDATE furumusic__track + SET cover_file_id = NULL, + updated_at = $3 + WHERE id = $1 + AND cover_file_id = $2"#, + ) + .bind(row.entity_id) + .bind(row.media_file_id) + .bind(now_iso()) + .execute(&ctx.pool) + .await?; + + if result.rows_affected() > 0 { + stats.broken_track_refs_cleared += 1; + log.warn(&format!( + "Track {}: cleared missing cover reference media_file_id={}{}", + row.entity_id, + row.media_file_id, + artwork_ref_location(storage_dir, row.file_path.as_deref()) + )); + } + } + + Ok(()) +} + +async fn repair_missing_artist_image_refs( + ctx: &JobContext, + log: &mut JobLog, + storage_dir: &str, + stats: &mut ArtworkStats, +) -> anyhow::Result<()> { + let rows = sqlx::query_as::<_, ArtworkRefCandidate>( + r#"SELECT a.id AS entity_id, + a.image_file_id AS media_file_id, + mf.file_path::text AS file_path + FROM furumusic__artist a + LEFT JOIN furumusic__media_file mf ON mf.id = a.image_file_id + WHERE a.image_file_id IS NOT NULL + AND a.is_hidden = false + ORDER BY a.id"#, + ) + .fetch_all(&ctx.pool) + .await?; + + for row in rows { + if artwork_ref_exists(storage_dir, row.file_path.as_deref()) { + continue; + } + + let result = sqlx::query( + r#"UPDATE furumusic__artist + SET image_file_id = NULL, + updated_at = $3 + WHERE id = $1 + AND image_file_id = $2"#, + ) + .bind(row.entity_id) + .bind(row.media_file_id) + .bind(now_iso()) + .execute(&ctx.pool) + .await?; + + if result.rows_affected() > 0 { + reset_lookup_state(&ctx.pool, "artist", row.entity_id).await?; + stats.broken_artist_refs_cleared += 1; + log.warn(&format!( + "Artist {}: cleared missing image reference media_file_id={}{}", + row.entity_id, + row.media_file_id, + artwork_ref_location(storage_dir, row.file_path.as_deref()) + )); + } + } + + Ok(()) +} + +fn artwork_ref_exists(storage_dir: &str, file_path: Option<&str>) -> bool { + file_path + .map(|value| crate::media_paths::resolve_media_file_path(storage_dir, value).exists()) + .unwrap_or(false) +} + +fn artwork_ref_location(storage_dir: &str, file_path: Option<&str>) -> String { + file_path + .map(|value| { + let path = crate::media_paths::resolve_media_file_path(storage_dir, value); + format!(" at {}", path.display()) + }) + .unwrap_or_else(|| " with missing media_file row".to_string()) +} + async fn backfill_release_local( ctx: &JobContext, log: &mut JobLog, @@ -475,11 +693,15 @@ async fn backfill_artist_lastfm( let artists = sqlx::query_as::<_, ArtistCandidate>( r#"SELECT a.id, a.name::text AS name FROM furumusic__artist a + LEFT JOIN furumusic__media_file mf ON mf.id = a.image_file_id LEFT JOIN furumusic__artwork_lookup_state s ON s.entity_kind = 'artist' AND s.entity_id = a.id AND s.source = 'lastfm' - WHERE a.image_file_id IS NULL + WHERE ( + a.image_file_id IS NULL + OR mf.file_path NOT LIKE '%/__artist_image__/%' + ) AND a.is_hidden = false AND ( s.entity_id IS NULL @@ -532,7 +754,15 @@ async fn backfill_artist_lastfm( SET image_file_id = $1, updated_at = $3 WHERE id = $2 - AND image_file_id IS NULL"#, + AND ( + image_file_id IS NULL + OR EXISTS ( + SELECT 1 + FROM furumusic__media_file mf + WHERE mf.id = furumusic__artist.image_file_id + AND mf.file_path NOT LIKE '%/__artist_image__/%' + ) + )"#, ) .bind(image_file_id) .bind(artist.id) @@ -659,6 +889,70 @@ async fn backfill_artist_lastfm( Ok(()) } +async fn backfill_artist_album_fallbacks( + ctx: &JobContext, + log: &mut JobLog, + stats: &mut ArtworkStats, +) -> anyhow::Result<()> { + let artists = sqlx::query_as::<_, ArtistCandidate>( + r#"SELECT a.id, a.name::text AS name + FROM furumusic__artist a + WHERE a.image_file_id IS NULL + AND a.is_hidden = false + AND EXISTS ( + SELECT 1 + FROM furumusic__release_artist ra + JOIN furumusic__release r ON r.id = ra.release_id + WHERE ra.artist_id = a.id + AND r.cover_file_id IS NOT NULL + AND r.is_hidden = false + UNION + SELECT 1 + FROM furumusic__track_artist ta + JOIN furumusic__track t ON t.id = ta.track_id + JOIN furumusic__release r ON r.id = t.release_id + WHERE ta.artist_id = a.id + AND r.cover_file_id IS NOT NULL + AND r.is_hidden = false + ) + ORDER BY a.id"#, + ) + .fetch_all(&ctx.pool) + .await?; + + if artists.is_empty() { + log.info("Artist album fallback pass: no artists need local album fallback"); + return Ok(()); + } + + log.info(&format!( + "Artist album fallback pass: checking {} artist(s) without images", + artists.len() + )); + + for artist in artists { + match assign_artist_album_fallback(ctx, artist.id).await { + Ok(Some(media_file_id)) => { + stats.artist_album_fallback_assigned += 1; + log.info(&format!( + "Artist {} \"{}\": assigned local album cover fallback (media_file_id={media_file_id})", + artist.id, artist.name + )); + } + Ok(None) => {} + Err(err) => { + stats.failed += 1; + log.warn(&format!( + "Artist {} \"{}\": failed to assign album fallback artwork: {err}", + artist.id, artist.name + )); + } + } + } + + Ok(()) +} + async fn repair_cover_variants( ctx: &JobContext, log: &mut JobLog, @@ -666,17 +960,25 @@ async fn repair_cover_variants( stats: &mut ArtworkStats, ) -> anyhow::Result<()> { let rows: Vec<(i64, String)> = sqlx::query_as( - "SELECT id, file_path FROM furumusic__media_file WHERE file_type = 'cover_art' ORDER BY id", + r#"SELECT DISTINCT mf.id, mf.file_path::text + FROM furumusic__media_file mf + WHERE mf.file_type = 'cover_art' + AND ( + EXISTS (SELECT 1 FROM furumusic__release r WHERE r.cover_file_id = mf.id) + OR EXISTS (SELECT 1 FROM furumusic__track t WHERE t.cover_file_id = mf.id) + OR EXISTS (SELECT 1 FROM furumusic__artist a WHERE a.image_file_id = mf.id) + ) + ORDER BY mf.id"#, ) .fetch_all(&ctx.pool) .await?; if rows.is_empty() { - log.info("Cover variant pass: no cover art media files found"); + log.info("Cover variant pass: no referenced cover art media files found"); return Ok(()); } log.info(&format!( - "Cover variant pass: checking {} cover art media file(s)", + "Cover variant pass: checking {} referenced cover art media file(s)", rows.len() )); @@ -805,6 +1107,18 @@ async fn fetch_lastfm_artist_image( client: &Client, api_key: &str, artist: &str, +) -> anyhow::Result> { + if let Some(image_url) = fetch_lastfm_artist_info_image(client, api_key, artist).await? { + return Ok(Some(image_url)); + } + + fetch_lastfm_artist_top_album_image(client, api_key, artist).await +} + +async fn fetch_lastfm_artist_info_image( + client: &Client, + api_key: &str, + artist: &str, ) -> anyhow::Result> { let response = client .get("https://ws.audioscrobbler.com/2.0/") @@ -836,6 +1150,70 @@ async fn fetch_lastfm_artist_image( .and_then(|artist| choose_best_image(artist.image))) } +async fn fetch_lastfm_artist_top_album_image( + client: &Client, + api_key: &str, + artist: &str, +) -> anyhow::Result> { + let response = client + .get("https://ws.audioscrobbler.com/2.0/") + .query(&[ + ("method", "artist.getTopAlbums"), + ("api_key", api_key), + ("artist", artist), + ("autocorrect", "1"), + ("limit", "10"), + ("format", "json"), + ]) + .send() + .await?; + let body = response.text().await?; + let parsed: LastfmTopAlbumsResponse = serde_json::from_str(&body)?; + if let Some(code) = parsed.error { + if code == 6 || code == 7 { + return Ok(None); + } + if code == 29 { + anyhow::bail!("Last.fm rate limit exceeded"); + } + anyhow::bail!( + "Last.fm API error {code}: {}", + parsed.message.unwrap_or_default() + ); + } + + let albums = parsed + .topalbums + .map(|topalbums| topalbums.album) + .unwrap_or_default(); + Ok(albums + .into_iter() + .filter_map(|album| choose_best_image(album.image)) + .next()) +} + +fn deserialize_one_or_many<'de, D, T>(deserializer: D) -> Result, D::Error> +where + D: de::Deserializer<'de>, + T: DeserializeOwned, +{ + let value = Option::::deserialize(deserializer)?; + let Some(value) = value else { + return Ok(Vec::new()); + }; + + match value { + serde_json::Value::Array(values) => values + .into_iter() + .map(|value| serde_json::from_value(value).map_err(de::Error::custom)) + .collect(), + serde_json::Value::Object(_) => serde_json::from_value(value) + .map(|item| vec![item]) + .map_err(de::Error::custom), + _ => Ok(Vec::new()), + } +} + fn choose_best_image(images: Option>) -> Option { let mut images = images.unwrap_or_default(); images.sort_by_key(|image| image_size_rank(&image.size)); @@ -946,6 +1324,24 @@ async fn record_lookup_state( Ok(()) } +async fn reset_lookup_state( + pool: &sqlx::PgPool, + entity_kind: &str, + entity_id: i64, +) -> anyhow::Result<()> { + sqlx::query( + r#"DELETE FROM furumusic__artwork_lookup_state + WHERE entity_kind = $1 + AND entity_id = $2 + AND source = 'lastfm'"#, + ) + .bind(entity_kind) + .bind(entity_id) + .execute(pool) + .await?; + Ok(()) +} + fn cover_source_description(source: &CoverSource) -> String { match source { CoverSource::FolderFile(path) => format!("folder: {}", path.display()), diff --git a/src/jobs/inbox_discover.rs b/src/jobs/inbox_discover.rs index 782edce..d3e8cec 100644 --- a/src/jobs/inbox_discover.rs +++ b/src/jobs/inbox_discover.rs @@ -75,7 +75,9 @@ impl Job for InboxDiscoverJob { for (_folder, files) in &groups { for file_path in files { - let input_path_str = file_path.to_string_lossy().to_string(); + let input_path_str = + crate::media_paths::path_for_root(&config.agent_inbox_dir, file_path) + .unwrap_or_else(|| file_path.to_string_lossy().to_string()); // Skip if a PendingReview already exists for this path match PendingReview::exists_for_path(&ctx.db, &input_path_str).await { diff --git a/src/jobs/inbox_process.rs b/src/jobs/inbox_process.rs index 16af129..6dd0a47 100644 --- a/src/jobs/inbox_process.rs +++ b/src/jobs/inbox_process.rs @@ -225,14 +225,13 @@ fn group_reviews_by_folder( reviews: &[PendingReview], inbox_dir: &str, ) -> Vec<(String, Vec)> { - let inbox = Path::new(inbox_dir); let mut map: HashMap> = HashMap::new(); for r in reviews { - let path = Path::new(r.input_path_str()); - let folder = path.parent().unwrap_or(path); - let rel = folder.strip_prefix(inbox).unwrap_or(folder); - let key = rel.to_string_lossy().to_string(); + let path = crate::media_paths::resolve_path_from_root(inbox_dir, r.input_path_str()); + let folder = path.parent().unwrap_or(path.as_path()); + let key = crate::media_paths::path_for_root(inbox_dir, folder) + .unwrap_or_else(|| folder.to_string_lossy().to_string()); map.entry(key).or_default().push(r.clone()); } @@ -287,8 +286,9 @@ async fn process_folder_batch( let mut failed_reviews: Vec = Vec::new(); for mut review in reviews { - let input_path_str = review.input_path_str().to_owned(); - let file_path = Path::new(&input_path_str); + let stored_input_path = review.input_path_str().to_owned(); + let file_path = + crate::media_paths::resolve_path_from_root(&config.agent_inbox_dir, &stored_input_path); let filename = file_path .file_name() .and_then(|n| n.to_str()) @@ -336,7 +336,7 @@ async fn process_folder_batch( }; // Parse path hints - let relative = file_path.strip_prefix(inbox_path).unwrap_or(file_path); + let relative = file_path.strip_prefix(inbox_path).unwrap_or(&file_path); let uploader = crate::jobs::uploader_from_relative_path(pool, relative).await; let hinted_relative = crate::jobs::strip_user_upload_prefix(relative); let hints = crate::agent::path_hints::parse(&hinted_relative); @@ -471,8 +471,11 @@ async fn process_folder_batch( // Build folder context from the first file's folder let folder_ctx = { - let first_path = Path::new(prepared[0].review.input_path_str()); - let folder = first_path.parent().unwrap_or(first_path); + let first_path = crate::media_paths::resolve_path_from_root( + &config.agent_inbox_dir, + prepared[0].review.input_path_str(), + ); + let folder = first_path.parent().unwrap_or(first_path.as_path()); let mut folder_files: Vec = std::fs::read_dir(folder) .ok() .map(|rd| { @@ -631,7 +634,11 @@ async fn process_folder_batch( p.review.result_json = Some(result_json); let _ = p.review.save(db).await; - let input_path_str = p.review.input_path_str().to_owned(); + let input_path = crate::media_paths::resolve_path_from_root( + &config.agent_inbox_dir, + p.review.input_path_str(), + ); + let input_path_str = input_path.to_string_lossy().to_string(); if confidence >= config.agent_confidence_threshold { match finalize_approved( @@ -787,10 +794,10 @@ pub async fn finalize_approved( format!("{}.{}", sanitize_filename(track_title), ext) }; - let storage_dir = Path::new(storage_dir_str); + let storage_dir = crate::media_paths::resolve_config_path_buf(storage_dir_str); let storage_path = if source_path.exists() { match mover::move_to_storage( - storage_dir, + &storage_dir, artist_name, release_title, &dest_filename, diff --git a/src/media_paths.rs b/src/media_paths.rs index 581b6d4..02b3788 100644 --- a/src/media_paths.rs +++ b/src/media_paths.rs @@ -1,7 +1,5 @@ use std::path::{Component, Path, PathBuf}; -const KNOWN_MEDIA_ROOTS: &[&str] = &["media/library", "media/uploads"]; - pub fn resolve_config_path(value: &str) -> String { let path = resolve_config_path_buf(value); if path.as_os_str().is_empty() { @@ -18,97 +16,75 @@ pub fn resolve_config_path_buf(value: &str) -> PathBuf { } let normalized = normalize_slashes(trimmed); - if is_host_absolute(&normalized) { - return PathBuf::from(normalized); + if is_absolute_path(&normalized) { + PathBuf::from(normalized) + } else { + app_root().join(slash_path(&normalized)) } - - if looks_like_windows_absolute(&normalized) { - if let Some(relative) = extract_known_media_root(&normalized) { - return app_root().join(slash_path(&relative)); - } - return PathBuf::from(normalized); - } - - app_root().join(slash_path(&normalized)) } pub fn resolve_media_file_path(storage_dir: &str, file_path: &str) -> PathBuf { - let storage_root = resolve_config_path_buf(storage_dir); - if let Some(relative) = normalize_stored_media_file_path(storage_dir, file_path) { - return storage_root.join(slash_path(&relative)); - } - - let normalized = normalize_slashes(file_path.trim()); - let path = PathBuf::from(&normalized); - if path.is_absolute() { - path - } else { - storage_root.join(path) - } + resolve_path_from_root(storage_dir, file_path) } pub fn media_file_path_for_storage(storage_dir: &str, path: &Path) -> Option { - let storage_root = resolve_config_path_buf(storage_dir); - if let Ok(relative) = path.strip_prefix(&storage_root) { - return relative_path_string(relative); - } - - let normalized = normalize_slashes(&path.to_string_lossy()); - relative_after_storage_marker(&storage_root, &normalized).or_else(|| { - if !is_host_absolute(&normalized) && !looks_like_windows_absolute(&normalized) { - normalize_relative_path(&normalized) - } else { - None - } - }) + path_for_root(storage_dir, path) } -pub fn normalize_stored_media_file_path(storage_dir: &str, file_path: &str) -> Option { - let trimmed = file_path.trim(); - if trimmed.is_empty() { - return None; +pub fn resolve_path_from_root(root_dir: &str, stored_path: &str) -> PathBuf { + let normalized = normalize_slashes(stored_path.trim()); + if is_absolute_path(&normalized) { + PathBuf::from(normalized) + } else { + resolve_config_path_buf(root_dir).join(slash_path(&normalized)) + } +} + +pub fn path_for_root(root_dir: &str, path: &Path) -> Option { + let root = resolve_config_path_buf(root_dir); + let normalized = normalize_slashes(&path.to_string_lossy()); + if is_absolute_path(&normalized) { + return strip_root_prefix(&root, &normalized); } - let storage_root = resolve_config_path_buf(storage_dir); - let normalized = normalize_slashes(trimmed); - let path = PathBuf::from(&normalized); - if path.is_absolute() { - if let Ok(relative) = path.strip_prefix(&storage_root) { - return relative_path_string(relative); - } - return relative_after_storage_marker(&storage_root, &normalized); - } - - if looks_like_windows_absolute(&normalized) { - return relative_after_storage_marker(&storage_root, &normalized); - } - - if let Some(relative) = relative_after_storage_marker_prefix(&storage_root, &normalized) { - return Some(relative); - } - - normalize_relative_path(&normalized) + relative_path_string(path) } pub async fn normalize_media_file_paths( pool: &sqlx::PgPool, storage_dir: &str, ) -> anyhow::Result { - let rows: Vec<(i64, String)> = - sqlx::query_as("SELECT id, file_path FROM furumusic__media_file ORDER BY id") - .fetch_all(pool) - .await?; + normalize_table_paths(pool, "furumusic__media_file", "file_path", storage_dir).await +} + +pub async fn normalize_pending_review_paths( + pool: &sqlx::PgPool, + inbox_dir: &str, +) -> anyhow::Result { + normalize_table_paths(pool, "furumusic__pending_review", "input_path", inbox_dir).await +} + +async fn normalize_table_paths( + pool: &sqlx::PgPool, + table: &str, + column: &str, + root_dir: &str, +) -> anyhow::Result { + let sql = format!("SELECT id, {column} FROM {table} WHERE {column} IS NOT NULL ORDER BY id"); + let rows: Vec<(i64, String)> = sqlx::query_as(&sql).fetch_all(pool).await?; let mut updated = 0; - for (id, file_path) in rows { - let Some(relative) = normalize_stored_media_file_path(storage_dir, &file_path) else { + for (id, stored_path) in rows { + let Some(normalized) = normalize_stored_path(root_dir, &stored_path) else { continue; }; - if relative == file_path { + if normalized == stored_path { continue; } - sqlx::query("UPDATE furumusic__media_file SET file_path = $1 WHERE id = $2") - .bind(&relative) + + let sql = format!("UPDATE {table} SET {column} = $1 WHERE id = $2"); + sqlx::query(&sql) + .bind(&normalized) .bind(id) .execute(pool) .await?; @@ -118,6 +94,19 @@ pub async fn normalize_media_file_paths( Ok(updated) } +fn normalize_stored_path(root_dir: &str, stored_path: &str) -> Option { + let normalized = normalize_slashes(stored_path); + if normalized.is_empty() { + return None; + } + + if is_absolute_path(&normalized) { + strip_root_prefix(&resolve_config_path_buf(root_dir), &normalized) + } else { + normalize_relative_path(&normalized) + } +} + fn app_root() -> PathBuf { std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")) } @@ -126,8 +115,8 @@ fn normalize_slashes(value: &str) -> String { value.trim().replace('\\', "/") } -fn is_host_absolute(value: &str) -> bool { - Path::new(value).is_absolute() +fn is_absolute_path(value: &str) -> bool { + value.starts_with('/') || Path::new(value).is_absolute() || looks_like_windows_absolute(value) } fn looks_like_windows_absolute(value: &str) -> bool { @@ -156,6 +145,35 @@ fn normalize_relative_path(value: &str) -> Option { Some(parts.join("/")) } +fn strip_root_prefix(root: &Path, normalized_path: &str) -> Option { + let root_string = normalize_slashes(&root.to_string_lossy()); + let root_trimmed = root_string.trim_end_matches('/'); + let path_trimmed = normalized_path.trim(); + + let root_cmp = comparable_path(root_trimmed); + let path_cmp = comparable_path(path_trimmed); + if path_cmp == root_cmp { + return None; + } + + let prefix = format!("{root_cmp}/"); + if path_cmp.starts_with(&prefix) { + let tail = &path_trimmed[root_trimmed.len() + 1..]; + return normalize_relative_path(tail); + } + + None +} + +fn comparable_path(value: &str) -> String { + let normalized = normalize_slashes(value).trim_end_matches('/').to_owned(); + if cfg!(windows) || looks_like_windows_absolute(&normalized) { + normalized.to_ascii_lowercase() + } else { + normalized + } +} + fn relative_path_string(path: &Path) -> Option { let mut parts = Vec::new(); for component in path.components() { @@ -172,75 +190,6 @@ fn relative_path_string(path: &Path) -> Option { } } -fn extract_known_media_root(value: &str) -> Option { - KNOWN_MEDIA_ROOTS - .iter() - .filter_map(|marker| relative_from_marker(value, marker, true)) - .next() -} - -fn relative_after_storage_marker(storage_root: &Path, value: &str) -> Option { - let marker = storage_marker(storage_root)?; - relative_from_marker(value, &marker, false) -} - -fn relative_after_storage_marker_prefix(storage_root: &Path, value: &str) -> Option { - let marker = storage_marker(storage_root)?; - let normalized = normalize_slashes(value); - let normalized_lower = normalized.to_ascii_lowercase(); - let marker_lower = marker.to_ascii_lowercase(); - if normalized_lower == marker_lower { - return None; - } - normalized_lower - .strip_prefix(&(marker_lower + "/")) - .and_then(|_| normalize_relative_path(&normalized[marker.len() + 1..])) -} - -fn storage_marker(storage_root: &Path) -> Option { - let parts: Vec = storage_root - .components() - .filter_map(|component| match component { - Component::Normal(value) => Some(value.to_string_lossy().to_string()), - _ => None, - }) - .collect(); - - if parts.len() >= 2 { - Some(format!( - "{}/{}", - parts[parts.len() - 2], - parts[parts.len() - 1] - )) - } else { - parts.last().cloned() - } -} - -fn relative_from_marker(value: &str, marker: &str, include_marker: bool) -> Option { - let normalized = normalize_slashes(value); - let haystack = format!("/{}", normalized.trim_matches('/')); - let marker = marker.trim_matches('/'); - let needle = format!("/{marker}"); - let haystack_lower = haystack.to_ascii_lowercase(); - let needle_lower = needle.to_ascii_lowercase(); - let index = haystack_lower.rfind(&needle_lower)?; - let after_marker = index + needle.len(); - if after_marker < haystack.len() && haystack.as_bytes().get(after_marker) != Some(&b'/') { - return None; - } - let tail = haystack[after_marker..].trim_matches('/'); - if include_marker { - if tail.is_empty() { - Some(marker.to_string()) - } else { - Some(format!("{marker}/{tail}")) - } - } else { - normalize_relative_path(tail) - } -} - #[cfg(test)] mod tests { use super::*; @@ -252,11 +201,26 @@ mod tests { } #[test] - fn maps_foreign_windows_config_media_root_to_app_root() { - let expected = app_root().join("media").join("uploads"); + fn keeps_absolute_config_path() { + assert_eq!(resolve_config_path_buf("/media"), PathBuf::from("/media")); + } + + #[test] + fn resolves_relative_media_file_under_storage_root() { assert_eq!( - resolve_config_path_buf(r"C:\Users\ab\repos\furumusic\media\uploads"), - expected + resolve_media_file_path("/media", "Buckethead/Pike/cover.jpg"), + PathBuf::from("/media") + .join("Buckethead") + .join("Pike") + .join("cover.jpg") + ); + } + + #[test] + fn keeps_absolute_media_file_path() { + assert_eq!( + resolve_media_file_path("/media", "/media/Buckethead/Pike/cover.jpg"), + PathBuf::from("/media/Buckethead/Pike/cover.jpg") ); } @@ -271,40 +235,22 @@ mod tests { } #[test] - fn normalizes_legacy_windows_media_file_path() { - let storage = app_root().join("media").join("library"); + fn stores_windows_path_relative_to_windows_storage_root() { assert_eq!( - normalize_stored_media_file_path( - &storage.to_string_lossy(), - r"C:\Users\ab\repos\furumusic\media\library\Buckethead\Pike\cover.jpg", + path_for_root( + r"C:\Users\ab\repos\furumusic\library", + Path::new(r"C:\Users\ab\repos\furumusic\library\Artist\Album\track.mp3"), ) .as_deref(), - Some("Buckethead/Pike/cover.jpg") + Some("Artist/Album/track.mp3") ); } #[test] - fn strips_accidental_relative_storage_root_prefix() { - let storage = app_root().join("media").join("library"); + fn normalizes_relative_backslashes() { assert_eq!( - normalize_stored_media_file_path( - &storage.to_string_lossy(), - "media/library/Buckethead/Pike/cover.jpg", - ) - .as_deref(), - Some("Buckethead/Pike/cover.jpg") - ); - } - - #[test] - fn resolves_legacy_windows_media_file_path_to_current_storage() { - let storage = app_root().join("media").join("library"); - assert_eq!( - resolve_media_file_path( - &storage.to_string_lossy(), - r"C:\Users\ab\repos\furumusic\media\library\Buckethead\Pike\cover.jpg", - ), - storage.join("Buckethead").join("Pike").join("cover.jpg") + normalize_stored_path("/media", r"Artist\Album\track.mp3").as_deref(), + Some("Artist/Album/track.mp3") ); } } diff --git a/src/player/mod.rs b/src/player/mod.rs index a73f566..a5ab7ca 100644 --- a/src/player/mod.rs +++ b/src/player/mod.rs @@ -3907,7 +3907,6 @@ impl App for PlayerApp { { let pool = Arc::clone(&pool); let pool_config = Arc::clone(&pool_config); - let config = Arc::clone(&self.config); get( move |session: Session, db: Database, @@ -3915,7 +3914,6 @@ impl App for PlayerApp { request: cot::request::Request| { let pool = Arc::clone(&pool); let pool_config = Arc::clone(&pool_config); - let config = Arc::clone(&config); async move { let pg_pool = pool .get_or_init(|| async { @@ -3926,7 +3924,9 @@ impl App for PlayerApp { .expect("player pool") }) .await; - stream_handler(session, db, pg_pool, &config, &request, path).await + let (live_config, _) = AppConfig::load_with_db(&db).await; + stream_handler(session, db, pg_pool, &live_config, &request, path) + .await } }, ) @@ -3939,12 +3939,10 @@ impl App for PlayerApp { { let pool = Arc::clone(&pool); let pool_config = Arc::clone(&pool_config); - let config = Arc::clone(&self.config); get( move |session: Session, db: Database, path: Path| { let pool = Arc::clone(&pool); let pool_config = Arc::clone(&pool_config); - let config = Arc::clone(&config); async move { let pg_pool = pool .get_or_init(|| async { @@ -3955,7 +3953,9 @@ impl App for PlayerApp { .expect("player pool") }) .await; - cover_variant_handler(session, db, pg_pool, &config, path).await + let (live_config, _) = AppConfig::load_with_db(&db).await; + cover_variant_handler(session, db, pg_pool, &live_config, path) + .await } }, ) @@ -3967,12 +3967,10 @@ impl App for PlayerApp { { let pool = Arc::clone(&pool); let pool_config = Arc::clone(&pool_config); - let config = Arc::clone(&self.config); get( move |session: Session, db: Database, path: Path| { let pool = Arc::clone(&pool); let pool_config = Arc::clone(&pool_config); - let config = Arc::clone(&config); async move { let pg_pool = pool .get_or_init(|| async { @@ -3983,7 +3981,8 @@ impl App for PlayerApp { .expect("player pool") }) .await; - cover_handler(session, db, pg_pool, &config, path).await + let (live_config, _) = AppConfig::load_with_db(&db).await; + cover_handler(session, db, pg_pool, &live_config, path).await } }, ) diff --git a/src/scheduler/mod.rs b/src/scheduler/mod.rs index cfeb348..53b9462 100644 --- a/src/scheduler/mod.rs +++ b/src/scheduler/mod.rs @@ -1481,6 +1481,20 @@ pub async fn start_scheduler( Err(e) => tracing::warn!("Failed to normalize media file paths: {e:#}"), } } + if !live_config.agent_inbox_dir.trim().is_empty() { + match crate::media_paths::normalize_pending_review_paths( + &pool, + &live_config.agent_inbox_dir, + ) + .await + { + Ok(0) => {} + Ok(n) => { + tracing::info!("Normalized {n} pending review path(s) to relative inbox paths") + } + Err(e) => tracing::warn!("Failed to normalize pending review paths: {e:#}"), + } + } // Upsert ScheduledJob rows for job in registry.all_jobs() {