ab/furumusic
1
0
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects Releases Activity

CORE: fixed media links
Build and Publish / Build and Publish Docker Image (push) Successful in 2m55s
Details

Browse Source
This commit is contained in:
Hills Eternity
2026-05-28 12:02:02 +03:00
parent c43ee02b00
commit 0cb731fb26
10 changed files with 618 additions and 225 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Cargo.lock
Generated
+1 -1
View File
@@ -1418,7 +1418,7 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
[[package]]
name = "furumusic"
version = "0.1.22"
version = "0.2.1"
dependencies = [
"anyhow",
"async-trait",
Cargo.toml
+1 -1
View File
@@ -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"
src/agent/cover_art.rs
+37 -12
View File
@@ -323,28 +323,51 @@ 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?
{
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);
}
}
let ext = extension_for_mime(&cover.mime_type);
let filename = format!("cover.{ext}");
@@ -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);
src/config.rs
+13 -9
View File
@@ -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");
}
src/jobs/artwork_backfill.rs
+403 -7
View File
@@ -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<String>,
}
#[derive(Debug, Deserialize)]
struct LastfmAlbumResponse {
album: Option<LastfmImageContainer>,
@@ -40,6 +50,24 @@ struct LastfmArtistResponse {
message: Option<String>,
}
#[derive(Debug, Deserialize)]
struct LastfmTopAlbumsResponse {
topalbums: Option<LastfmTopAlbumsContainer>,
error: Option<i32>,
message: Option<String>,
}
#[derive(Debug, Deserialize)]
struct LastfmTopAlbumsContainer {
#[serde(default, deserialize_with = "deserialize_one_or_many")]
album: Vec<LastfmTopAlbum>,
}
#[derive(Debug, Deserialize)]
struct LastfmTopAlbum {
image: Option<Vec<LastfmImage>>,
}
#[derive(Debug, Deserialize)]
struct LastfmImageContainer {
image: Option<Vec<LastfmImage>>,
@@ -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<Option<String>> {
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<Option<String>> {
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<Option<String>> {
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<Vec<T>, D::Error>
where
D: de::Deserializer<'de>,
T: DeserializeOwned,
{
let value = Option::<serde_json::Value>::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<Vec<LastfmImage>>) -> Option<String> {
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()),
src/jobs/inbox_discover.rs
+3 -1
View File
@@ -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 {
src/jobs/inbox_process.rs
+20 -13
View File
@@ -225,14 +225,13 @@ fn group_reviews_by_folder(
reviews: &[PendingReview],
inbox_dir: &str,
) -> Vec<(String, Vec<PendingReview>)> {
let inbox = Path::new(inbox_dir);
let mut map: HashMap<String, Vec<PendingReview>> = 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<PendingReview> = 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<String> = 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,
src/media_paths.rs
+117 -171
View File
@@ -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 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);
}
if is_absolute_path(&normalized) {
PathBuf::from(normalized)
} else {
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<String> {
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<String> {
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<String> {
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<u64> {
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<u64> {
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<u64> {
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<String> {
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<String> {
Some(parts.join("/"))
}
fn strip_root_prefix(root: &Path, normalized_path: &str) -> Option<String> {
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<String> {
let mut parts = Vec::new();
for component in path.components() {
@@ -172,75 +190,6 @@ fn relative_path_string(path: &Path) -> Option<String> {
}
}
fn extract_known_media_root(value: &str) -> Option<String> {
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<String> {
let marker = storage_marker(storage_root)?;
relative_from_marker(value, &marker, false)
}
fn relative_after_storage_marker_prefix(storage_root: &Path, value: &str) -> Option<String> {
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<String> {
let parts: Vec<String> = 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<String> {
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")
);
}
}
src/player/mod.rs
+8 -9
View File
@@ -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<PathMediaFileVariant>| {
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<PathMediaFileId>| {
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
}
},
)
src/scheduler/mod.rs
+14
View File
@@ -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() {