This commit is contained in:
Ultradesu
@@ -0,0 +1,568 @@
|
||||
use std::collections::HashSet;
|
||||
use std::io::ErrorKind;
|
||||
use std::path::PathBuf;
|
||||
|
||||
use anyhow::{Context, bail};
|
||||
use sqlx::{FromRow, PgPool, Postgres, Transaction};
|
||||
use uuid::Uuid;
|
||||
|
||||
#[derive(Debug, FromRow)]
|
||||
struct MediaFileRow {
|
||||
id: i64,
|
||||
file_type: String,
|
||||
file_path: String,
|
||||
sha256_hash: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, FromRow)]
|
||||
struct PlaybackStateRow {
|
||||
id: i64,
|
||||
current_track_id: Option<i64>,
|
||||
position_ms: i32,
|
||||
queue_json: String,
|
||||
queue_position: i32,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct QuarantinedFile {
|
||||
original: PathBuf,
|
||||
quarantined: PathBuf,
|
||||
}
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
struct Quarantine {
|
||||
root: Option<PathBuf>,
|
||||
files: Vec<QuarantinedFile>,
|
||||
}
|
||||
|
||||
pub async fn delete_tracks(
|
||||
pool: &PgPool,
|
||||
requested_track_ids: &[i64],
|
||||
storage_dir: &str,
|
||||
) -> anyhow::Result<u64> {
|
||||
delete_scope(pool, requested_track_ids, &[], storage_dir).await
|
||||
}
|
||||
|
||||
pub async fn delete_releases(
|
||||
pool: &PgPool,
|
||||
requested_release_ids: &[i64],
|
||||
storage_dir: &str,
|
||||
) -> anyhow::Result<u64> {
|
||||
let mut transaction = pool.begin().await?;
|
||||
let release_ids: Vec<i64> = sqlx::query_scalar(
|
||||
"SELECT id FROM furumusic__release WHERE id = ANY($1) ORDER BY id FOR UPDATE",
|
||||
)
|
||||
.bind(requested_release_ids)
|
||||
.fetch_all(&mut *transaction)
|
||||
.await?;
|
||||
if release_ids.is_empty() {
|
||||
transaction.rollback().await?;
|
||||
return Ok(0);
|
||||
}
|
||||
let track_ids: Vec<i64> = sqlx::query_scalar(
|
||||
"SELECT id FROM furumusic__track WHERE release_id = ANY($1) ORDER BY id FOR UPDATE",
|
||||
)
|
||||
.bind(&release_ids)
|
||||
.fetch_all(&mut *transaction)
|
||||
.await?;
|
||||
delete_locked_scope(transaction, track_ids, release_ids, storage_dir, true).await
|
||||
}
|
||||
|
||||
async fn delete_scope(
|
||||
pool: &PgPool,
|
||||
requested_track_ids: &[i64],
|
||||
release_ids: &[i64],
|
||||
storage_dir: &str,
|
||||
) -> anyhow::Result<u64> {
|
||||
let mut transaction = pool.begin().await?;
|
||||
let track_ids: Vec<i64> = sqlx::query_scalar(
|
||||
"SELECT id FROM furumusic__track WHERE id = ANY($1) ORDER BY id FOR UPDATE",
|
||||
)
|
||||
.bind(requested_track_ids)
|
||||
.fetch_all(&mut *transaction)
|
||||
.await?;
|
||||
if track_ids.is_empty() {
|
||||
transaction.rollback().await?;
|
||||
return Ok(0);
|
||||
}
|
||||
delete_locked_scope(
|
||||
transaction,
|
||||
track_ids,
|
||||
release_ids.to_vec(),
|
||||
storage_dir,
|
||||
false,
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
async fn delete_locked_scope(
|
||||
mut transaction: Transaction<'_, Postgres>,
|
||||
track_ids: Vec<i64>,
|
||||
release_ids: Vec<i64>,
|
||||
storage_dir: &str,
|
||||
delete_release_rows: bool,
|
||||
) -> anyhow::Result<u64> {
|
||||
let media_files = deletable_media_files(&mut transaction, &track_ids, &release_ids).await?;
|
||||
let quarantine = match quarantine_media_files(storage_dir, &media_files).await {
|
||||
Ok(quarantine) => quarantine,
|
||||
Err(error) => {
|
||||
transaction.rollback().await?;
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
|
||||
let deletion = delete_database_rows(
|
||||
&mut transaction,
|
||||
&track_ids,
|
||||
&release_ids,
|
||||
&media_files,
|
||||
delete_release_rows,
|
||||
)
|
||||
.await;
|
||||
let affected = match deletion {
|
||||
Ok(affected) => affected,
|
||||
Err(error) => {
|
||||
transaction.rollback().await?;
|
||||
restore_quarantine(&quarantine).await;
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
|
||||
if let Err(error) = transaction.commit().await {
|
||||
restore_quarantine(&quarantine).await;
|
||||
return Err(error.into());
|
||||
}
|
||||
purge_quarantine(&quarantine).await;
|
||||
remove_empty_storage_parents(storage_dir, &quarantine.files).await;
|
||||
Ok(affected)
|
||||
}
|
||||
|
||||
async fn deletable_media_files(
|
||||
transaction: &mut Transaction<'_, Postgres>,
|
||||
track_ids: &[i64],
|
||||
release_ids: &[i64],
|
||||
) -> anyhow::Result<Vec<MediaFileRow>> {
|
||||
Ok(sqlx::query_as(
|
||||
r#"WITH seed_media(id) AS (
|
||||
SELECT audio_file_id FROM furumusic__track WHERE id = ANY($1)
|
||||
UNION
|
||||
SELECT cover_file_id FROM furumusic__track
|
||||
WHERE id = ANY($1) AND cover_file_id IS NOT NULL
|
||||
UNION
|
||||
SELECT cover_file_id FROM furumusic__release
|
||||
WHERE id = ANY($2) AND cover_file_id IS NOT NULL
|
||||
), candidate_media(id) AS (
|
||||
SELECT id FROM seed_media
|
||||
UNION
|
||||
SELECT duplicate.id
|
||||
FROM furumusic__media_file duplicate
|
||||
JOIN furumusic__media_file seed
|
||||
ON duplicate.file_path = seed.file_path
|
||||
AND duplicate.sha256_hash = seed.sha256_hash
|
||||
JOIN seed_media ON seed_media.id = seed.id
|
||||
)
|
||||
SELECT mf.id, mf.file_type::text AS file_type, mf.file_path,
|
||||
mf.sha256_hash::text AS sha256_hash
|
||||
FROM furumusic__media_file mf
|
||||
JOIN candidate_media candidate ON candidate.id = mf.id
|
||||
WHERE NOT EXISTS (
|
||||
SELECT 1
|
||||
FROM furumusic__track track
|
||||
JOIN furumusic__media_file linked
|
||||
ON linked.id = track.audio_file_id
|
||||
OR linked.id = track.cover_file_id
|
||||
WHERE linked.file_path = mf.file_path
|
||||
AND linked.sha256_hash = mf.sha256_hash
|
||||
AND NOT (track.id = ANY($1))
|
||||
)
|
||||
AND NOT EXISTS (
|
||||
SELECT 1
|
||||
FROM furumusic__release release
|
||||
JOIN furumusic__media_file linked
|
||||
ON linked.id = release.cover_file_id
|
||||
WHERE linked.file_path = mf.file_path
|
||||
AND linked.sha256_hash = mf.sha256_hash
|
||||
AND NOT (release.id = ANY($2))
|
||||
)
|
||||
AND NOT EXISTS (
|
||||
SELECT 1
|
||||
FROM furumusic__artist artist
|
||||
JOIN furumusic__media_file linked
|
||||
ON linked.id = artist.image_file_id
|
||||
WHERE linked.file_path = mf.file_path
|
||||
AND linked.sha256_hash = mf.sha256_hash
|
||||
)
|
||||
AND NOT EXISTS (
|
||||
SELECT 1
|
||||
FROM furumusic__playlist playlist
|
||||
JOIN furumusic__media_file linked
|
||||
ON linked.id = playlist.cover_file_id
|
||||
WHERE linked.file_path = mf.file_path
|
||||
AND linked.sha256_hash = mf.sha256_hash
|
||||
)
|
||||
ORDER BY mf.id
|
||||
FOR UPDATE OF mf"#,
|
||||
)
|
||||
.bind(track_ids)
|
||||
.bind(release_ids)
|
||||
.fetch_all(&mut **transaction)
|
||||
.await?)
|
||||
}
|
||||
|
||||
async fn quarantine_media_files(
|
||||
storage_dir: &str,
|
||||
media_files: &[MediaFileRow],
|
||||
) -> anyhow::Result<Quarantine> {
|
||||
if media_files.is_empty() {
|
||||
return Ok(Quarantine::default());
|
||||
}
|
||||
if storage_dir.trim().is_empty() {
|
||||
bail!("agent_storage_dir is not configured; refusing to leave deleted tracks on disk");
|
||||
}
|
||||
|
||||
let storage_root = crate::media_paths::resolve_config_path_buf(storage_dir);
|
||||
if storage_root.parent().is_none() {
|
||||
bail!("agent_storage_dir must not be a filesystem root");
|
||||
}
|
||||
let quarantine_root = storage_root
|
||||
.join(".furumusic-trash")
|
||||
.join(Uuid::new_v4().to_string());
|
||||
let mut quarantine = Quarantine {
|
||||
root: Some(quarantine_root.clone()),
|
||||
files: Vec::new(),
|
||||
};
|
||||
let mut seen = HashSet::new();
|
||||
let result: anyhow::Result<()> =
|
||||
async {
|
||||
for media in media_files {
|
||||
let original = checked_storage_path(storage_dir, &media.file_path)?;
|
||||
let mut paths = vec![original.clone()];
|
||||
if media.file_type == "cover_art" {
|
||||
paths.extend(crate::agent::cover_variants::COVER_VARIANTS.iter().map(
|
||||
|variant| crate::agent::cover_variants::variant_path(&original, *variant),
|
||||
));
|
||||
}
|
||||
|
||||
for (index, path) in paths.into_iter().enumerate() {
|
||||
if !seen.insert(path.clone()) {
|
||||
continue;
|
||||
}
|
||||
match tokio::fs::symlink_metadata(&path).await {
|
||||
Ok(metadata) if metadata.is_file() || metadata.file_type().is_symlink() => {
|
||||
}
|
||||
Ok(_) => bail!("media path is not a regular file: {}", path.display()),
|
||||
Err(error) if error.kind() == ErrorKind::NotFound => continue,
|
||||
Err(error) => return Err(error.into()),
|
||||
}
|
||||
tokio::fs::create_dir_all(&quarantine_root).await?;
|
||||
let extension = path
|
||||
.extension()
|
||||
.and_then(|value| value.to_str())
|
||||
.unwrap_or("bin");
|
||||
let quarantined = quarantine_root.join(format!(
|
||||
"{}-{index}-{}.{}",
|
||||
media.id,
|
||||
Uuid::new_v4(),
|
||||
extension
|
||||
));
|
||||
tokio::fs::rename(&path, &quarantined)
|
||||
.await
|
||||
.with_context(|| format!("failed to remove {}", path.display()))?;
|
||||
quarantine.files.push(QuarantinedFile {
|
||||
original: path,
|
||||
quarantined,
|
||||
});
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
.await;
|
||||
match result {
|
||||
Ok(()) => Ok(quarantine),
|
||||
Err(error) => {
|
||||
restore_quarantine(&quarantine).await;
|
||||
Err(error)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn checked_storage_path(storage_dir: &str, stored_path: &str) -> anyhow::Result<PathBuf> {
|
||||
let resolved = crate::media_paths::resolve_media_file_path(storage_dir, stored_path);
|
||||
crate::media_paths::path_for_root(storage_dir, &resolved).with_context(|| {
|
||||
format!(
|
||||
"refusing to delete media outside agent_storage_dir: {}",
|
||||
resolved.display()
|
||||
)
|
||||
})?;
|
||||
Ok(resolved)
|
||||
}
|
||||
|
||||
async fn restore_quarantine(quarantine: &Quarantine) {
|
||||
for file in quarantine.files.iter().rev() {
|
||||
if let Some(parent) = file.original.parent() {
|
||||
let _ = tokio::fs::create_dir_all(parent).await;
|
||||
}
|
||||
let _ = tokio::fs::rename(&file.quarantined, &file.original).await;
|
||||
}
|
||||
if let Some(root) = &quarantine.root {
|
||||
let _ = tokio::fs::remove_dir_all(root).await;
|
||||
}
|
||||
}
|
||||
|
||||
async fn purge_quarantine(quarantine: &Quarantine) {
|
||||
if let Some(root) = &quarantine.root
|
||||
&& let Err(error) = tokio::fs::remove_dir_all(root).await
|
||||
&& error.kind() != ErrorKind::NotFound
|
||||
{
|
||||
tracing::warn!(path = %root.display(), error = %error, "failed to purge deleted media quarantine");
|
||||
}
|
||||
if let Some(parent) = quarantine.root.as_deref().and_then(|root| root.parent()) {
|
||||
let _ = tokio::fs::remove_dir(parent).await;
|
||||
}
|
||||
}
|
||||
|
||||
async fn remove_empty_storage_parents(storage_dir: &str, files: &[QuarantinedFile]) {
|
||||
let storage_root = crate::media_paths::resolve_config_path_buf(storage_dir);
|
||||
let mut seen = HashSet::new();
|
||||
for file in files {
|
||||
let mut current = file.original.parent();
|
||||
while let Some(directory) = current {
|
||||
if directory == storage_root || !directory.starts_with(&storage_root) {
|
||||
break;
|
||||
}
|
||||
if !seen.insert(directory.to_path_buf()) {
|
||||
break;
|
||||
}
|
||||
match tokio::fs::remove_dir(directory).await {
|
||||
Ok(()) => current = directory.parent(),
|
||||
Err(_) => break,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn delete_database_rows(
|
||||
transaction: &mut Transaction<'_, Postgres>,
|
||||
track_ids: &[i64],
|
||||
release_ids: &[i64],
|
||||
media_files: &[MediaFileRow],
|
||||
delete_release_rows: bool,
|
||||
) -> anyhow::Result<u64> {
|
||||
cleanup_playback_states(transaction, track_ids).await?;
|
||||
|
||||
for table in [
|
||||
"furumusic__playlist_track",
|
||||
"furumusic__user_liked_track",
|
||||
"furumusic__play_history",
|
||||
"furumusic__track_popularity_history",
|
||||
"furumusic__lastfm_scrobble_outbox",
|
||||
"furumusic__track_genre",
|
||||
"furumusic__track_artist",
|
||||
"furumusic__track_embedding",
|
||||
] {
|
||||
let query = format!("DELETE FROM {table} WHERE track_id = ANY($1)");
|
||||
sqlx::query(&query)
|
||||
.bind(track_ids)
|
||||
.execute(&mut **transaction)
|
||||
.await?;
|
||||
}
|
||||
for table in [
|
||||
"furumusic__entity_genre_tag",
|
||||
"furumusic__external_metadata_id",
|
||||
"furumusic__artwork_lookup_state",
|
||||
] {
|
||||
let query =
|
||||
format!("DELETE FROM {table} WHERE entity_kind = 'track' AND entity_id = ANY($1)");
|
||||
sqlx::query(&query)
|
||||
.bind(track_ids)
|
||||
.execute(&mut **transaction)
|
||||
.await?;
|
||||
}
|
||||
for table in [
|
||||
"furumusic__fed_state_like",
|
||||
"furumusic__fed_state_playlist_item",
|
||||
"furumusic__track_ref",
|
||||
"furumusic__listen_event",
|
||||
] {
|
||||
let query =
|
||||
format!("UPDATE {table} SET local_track_id = NULL WHERE local_track_id = ANY($1)");
|
||||
sqlx::query(&query)
|
||||
.bind(track_ids)
|
||||
.execute(&mut **transaction)
|
||||
.await?;
|
||||
}
|
||||
|
||||
let tracks_deleted = sqlx::query("DELETE FROM furumusic__track WHERE id = ANY($1)")
|
||||
.bind(track_ids)
|
||||
.execute(&mut **transaction)
|
||||
.await?
|
||||
.rows_affected();
|
||||
|
||||
if delete_release_rows {
|
||||
for table in [
|
||||
"furumusic__entity_genre_tag",
|
||||
"furumusic__external_metadata_id",
|
||||
"furumusic__artwork_lookup_state",
|
||||
] {
|
||||
let query = format!(
|
||||
"DELETE FROM {table} WHERE entity_kind = 'release' AND entity_id = ANY($1)"
|
||||
);
|
||||
sqlx::query(&query)
|
||||
.bind(release_ids)
|
||||
.execute(&mut **transaction)
|
||||
.await?;
|
||||
}
|
||||
sqlx::query("DELETE FROM furumusic__release_artist WHERE release_id = ANY($1)")
|
||||
.bind(release_ids)
|
||||
.execute(&mut **transaction)
|
||||
.await?;
|
||||
sqlx::query("DELETE FROM furumusic__release WHERE id = ANY($1)")
|
||||
.bind(release_ids)
|
||||
.execute(&mut **transaction)
|
||||
.await?;
|
||||
}
|
||||
|
||||
let media_ids: Vec<i64> = media_files.iter().map(|media| media.id).collect();
|
||||
if !media_ids.is_empty() {
|
||||
let media_hashes: Vec<String> = media_files
|
||||
.iter()
|
||||
.map(|media| media.sha256_hash.clone())
|
||||
.collect();
|
||||
sqlx::query(
|
||||
r#"UPDATE furumusic__youtube_download_item
|
||||
SET status = 'failed', progress_percent = 0,
|
||||
downloaded_bytes = 0, total_bytes = NULL,
|
||||
speed_bytes_per_sec = NULL, eta_seconds = NULL,
|
||||
error = 'Imported library files were deleted; this source can be imported again',
|
||||
completed_at = NULL, updated_at = $2
|
||||
WHERE id IN (
|
||||
SELECT item_id
|
||||
FROM furumusic__youtube_import_media
|
||||
WHERE media_file_id = ANY($1)
|
||||
)"#,
|
||||
)
|
||||
.bind(&media_ids)
|
||||
.bind(chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string())
|
||||
.execute(&mut **transaction)
|
||||
.await?;
|
||||
|
||||
let review_ids: Vec<i64> = sqlx::query_scalar(
|
||||
r#"SELECT id FROM furumusic__pending_review
|
||||
WHERE context_json IS NOT NULL
|
||||
AND substring(
|
||||
context_json
|
||||
from '"sha256"[[:space:]]*:[[:space:]]*"([0-9a-fA-F]{64})"'
|
||||
) = ANY($1)"#,
|
||||
)
|
||||
.bind(&media_hashes)
|
||||
.fetch_all(&mut **transaction)
|
||||
.await?;
|
||||
if !review_ids.is_empty() {
|
||||
sqlx::query(
|
||||
"DELETE FROM furumusic__processing_stats WHERE pending_review_id = ANY($1)",
|
||||
)
|
||||
.bind(&review_ids)
|
||||
.execute(&mut **transaction)
|
||||
.await?;
|
||||
sqlx::query("DELETE FROM furumusic__pending_review WHERE id = ANY($1)")
|
||||
.bind(&review_ids)
|
||||
.execute(&mut **transaction)
|
||||
.await?;
|
||||
}
|
||||
sqlx::query(
|
||||
"DELETE FROM furumusic__federation_content_id_cache WHERE media_file_id = ANY($1)",
|
||||
)
|
||||
.bind(&media_ids)
|
||||
.execute(&mut **transaction)
|
||||
.await?;
|
||||
sqlx::query("DELETE FROM furumusic__media_file WHERE id = ANY($1)")
|
||||
.bind(&media_ids)
|
||||
.execute(&mut **transaction)
|
||||
.await?;
|
||||
}
|
||||
Ok(if delete_release_rows {
|
||||
u64::try_from(release_ids.len()).unwrap_or(u64::MAX)
|
||||
} else {
|
||||
tracks_deleted
|
||||
})
|
||||
}
|
||||
|
||||
async fn cleanup_playback_states(
|
||||
transaction: &mut Transaction<'_, Postgres>,
|
||||
track_ids: &[i64],
|
||||
) -> anyhow::Result<()> {
|
||||
let deleted: HashSet<i64> = track_ids.iter().copied().collect();
|
||||
let states: Vec<PlaybackStateRow> = sqlx::query_as(
|
||||
"SELECT id, current_track_id, position_ms, queue_json, queue_position FROM furumusic__playback_state FOR UPDATE",
|
||||
)
|
||||
.fetch_all(&mut **transaction)
|
||||
.await?;
|
||||
|
||||
for state in states {
|
||||
let mut queue: Vec<i64> = serde_json::from_str(&state.queue_json).unwrap_or_default();
|
||||
let original_queue = queue.clone();
|
||||
queue.retain(|track_id| !deleted.contains(track_id));
|
||||
let current_track_id = state.current_track_id.filter(|id| !deleted.contains(id));
|
||||
if queue == original_queue && current_track_id == state.current_track_id {
|
||||
continue;
|
||||
}
|
||||
let queue_position = current_track_id
|
||||
.and_then(|current| queue.iter().position(|id| *id == current))
|
||||
.map(|position| i32::try_from(position).unwrap_or(i32::MAX))
|
||||
.unwrap_or_else(|| {
|
||||
if queue.is_empty() {
|
||||
0
|
||||
} else {
|
||||
state
|
||||
.queue_position
|
||||
.clamp(0, i32::try_from(queue.len() - 1).unwrap_or(i32::MAX))
|
||||
}
|
||||
});
|
||||
let position_ms = if current_track_id.is_some() {
|
||||
state.position_ms
|
||||
} else {
|
||||
0
|
||||
};
|
||||
let queue_json = serde_json::to_string(&queue)?;
|
||||
sqlx::query(
|
||||
r#"UPDATE furumusic__playback_state
|
||||
SET current_track_id = $2, position_ms = $3,
|
||||
queue_json = $4, queue_position = $5
|
||||
WHERE id = $1"#,
|
||||
)
|
||||
.bind(state.id)
|
||||
.bind(current_track_id)
|
||||
.bind(position_ms)
|
||||
.bind(queue_json)
|
||||
.bind(queue_position)
|
||||
.execute(&mut **transaction)
|
||||
.await?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn rejects_media_paths_outside_storage() {
|
||||
assert!(checked_storage_path("/srv/music", "/etc/passwd").is_err());
|
||||
assert!(checked_storage_path("/srv/music", "../outside.flac").is_err());
|
||||
assert_eq!(
|
||||
checked_storage_path("/srv/music", "Artist/Album/01.flac").unwrap(),
|
||||
PathBuf::from("/srv/music/Artist/Album/01.flac")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deleted_track_ids_are_removed_from_saved_queue() {
|
||||
let deleted = HashSet::from([2_i64, 4]);
|
||||
let mut queue = vec![1_i64, 2, 3, 4, 5];
|
||||
queue.retain(|track_id| !deleted.contains(track_id));
|
||||
assert_eq!(queue, vec![1, 3, 5]);
|
||||
let serialized: serde_json::Value =
|
||||
serde_json::from_str(&serde_json::to_string(&queue).unwrap()).unwrap();
|
||||
assert_eq!(serialized, serde_json::json!([1, 3, 5]));
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user