Extend DHT scheme with content_id

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "furumusic"
-version = "0.6.1-fd"
+version = "0.6.4-fd"
 edition = "2024"
 description = "Reusable web-app boilerplate: auth, OIDC/SSO, admin panel, user management, i18n, PostgreSQL"
 
@@ -16,6 +16,7 @@ reqwest = { version = "0.12", default-features = false, features = ["rustls-tls"
 tokio = { version = "1", features = ["sync", "fs", "io-util"] }
 tower = "0.5"
 base64 = "0.22"
+blake3 = "1"
 serde_json = "1"
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }

src/federation/mod.rs

@@ -21,7 +21,8 @@ use std::time::Duration;
 
 use anyhow::{Context, Result};
 use music_dht::{
-    ItemKind, ItemSpec, MusicDhtConfig, MusicDhtService, NetworkId, PeerTicket, RendezvousConfig,
+    ItemKind, ItemSpec, MusicDhtConfig, MusicDhtService, NetworkId, PeerTicket, PublishStats,
+    RendezvousConfig, SyncStats,
 };
 use serde_json::{Value, json};
 use sqlx::PgPool;
@@ -45,6 +46,8 @@ pub struct Federation {
     /// Transport data directory; server-side DHT state and identity live in PostgreSQL.
     data_dir: PathBuf,
     database_url: std::sync::Mutex<String>,
+    storage_dir: std::sync::Mutex<String>,
+    content_cache: std::sync::Mutex<std::collections::HashMap<i64, (String, String)>>,
     pool: tokio::sync::OnceCell<PgPool>,
     running: tokio::sync::Mutex<Option<Running>>,
     last_sync: std::sync::Mutex<Option<String>>,
@@ -68,6 +71,8 @@ pub fn handle() -> Arc<Federation> {
         Arc::new(Federation {
             data_dir: PathBuf::from(crate::media_paths::resolve_config_path("federation")),
             database_url: std::sync::Mutex::new(String::new()),
+            storage_dir: std::sync::Mutex::new(String::new()),
+            content_cache: std::sync::Mutex::new(Default::default()),
             pool: tokio::sync::OnceCell::new(),
             running: tokio::sync::Mutex::new(None),
             last_sync: std::sync::Mutex::new(None),
@@ -136,8 +141,7 @@ impl Federation {
                 }
                 "federation_network_id" => effective.federation_network_id = value,
                 "agent_storage_dir" => {
-                    effective.agent_storage_dir =
-                        crate::media_paths::resolve_config_path(&value);
+                    effective.agent_storage_dir = crate::media_paths::resolve_config_path(&value);
                 }
                 _ => {}
             }
@@ -149,6 +153,7 @@ impl Federation {
     /// node. Called at boot and every time the admin settings are saved.
     pub async fn apply(self: &Arc<Self>, config: &AppConfig) {
         *lock(&self.database_url) = config.database_url.clone();
+        *lock(&self.storage_dir) = config.agent_storage_dir.clone();
         let network = config.federation_network_id.trim().to_string();
         if config.federation_enabled && !network.is_empty() {
             if let Err(err) = self.start(network, config.agent_storage_dir.clone()).await {
@@ -208,7 +213,7 @@ impl Federation {
             let mut interval = tokio::time::interval(SYNC_INTERVAL);
             loop {
                 interval.tick().await;
-                sync_self.sync_once(&sync_service).await;
+                let _ = sync_self.sync_once(&sync_service).await;
             }
         });
         // Serve audio and catalog requests from other peers.
@@ -260,36 +265,39 @@ impl Federation {
     async fn spawn_sync_soon(self: &Arc<Self>) {
         if let Ok(service) = self.service().await {
             let fed = Arc::clone(self);
-            tokio::spawn(async move { fed.sync_once(&service).await });
+            tokio::spawn(async move {
+                let _ = fed.sync_once(&service).await;
+            });
         }
     }
 
     pub async fn sync_now(self: &Arc<Self>) -> Result<()> {
         let service = self.service().await?;
-        self.sync_once(&service).await;
+        let sync_stats = self.sync_once(&service).await?;
+        let publish_stats = match service.republish().await {
+            Ok(stats) => stats,
+            Err(err) => {
+                tracing::warn!("federation republish failed: {err}");
+                self.set_error(Some(format!("republish failed: {err}")));
+                anyhow::bail!("republish failed: {err}");
+            }
+        };
+        self.record_publish_success(sync_stats, publish_stats);
         Ok(())
     }
 
-    async fn sync_once(&self, service: &MusicDhtService) {
+    async fn sync_once(&self, service: &MusicDhtService) -> Result<SyncStats> {
         let specs = match self.collect_specs().await {
             Ok(specs) => specs,
             Err(err) => {
                 tracing::warn!("federation sync: library read failed: {err:#}");
                 self.set_error(Some(format!("library read failed: {err}")));
-                return;
+                anyhow::bail!("library read failed: {err}");
             }
         };
         match service.sync_library(specs).await {
             Ok(stats) => {
-                *lock(&self.last_sync) = Some(format!(
-                    "{} (+{} ~{} −{}, unchanged {}, failed {})",
-                    now_iso(),
-                    stats.added,
-                    stats.updated,
-                    stats.removed,
-                    stats.unchanged,
-                    stats.failed
-                ));
+                self.record_sync_success(stats);
                 if stats.failed > 0 {
                     self.set_error(Some(format!(
                         "{} item(s) failed to publish in the last sync",
@@ -298,24 +306,53 @@ impl Federation {
                 } else {
                     self.set_error(None);
                 }
+                Ok(stats)
             }
             Err(err) => {
                 tracing::warn!("federation sync failed: {err}");
                 self.set_error(Some(format!("sync failed: {err}")));
+                Err(anyhow::anyhow!("sync failed: {err}"))
             }
         }
     }
 
+    fn record_sync_success(&self, stats: SyncStats) {
+        *lock(&self.last_sync) = Some(format!(
+            "{} (+{} ~{} −{}, unchanged {}, failed {})",
+            now_iso(),
+            stats.added,
+            stats.updated,
+            stats.removed,
+            stats.unchanged,
+            stats.failed
+        ));
+    }
+
+    fn record_publish_success(&self, sync_stats: SyncStats, publish_stats: PublishStats) {
+        *lock(&self.last_sync) = Some(format!(
+            "{} (+{} ~{} −{}, unchanged {}, failed {}; republished {} records, {} keys, remote nodes {})",
+            now_iso(),
+            sync_stats.added,
+            sync_stats.updated,
+            sync_stats.removed,
+            sync_stats.unchanged,
+            sync_stats.failed,
+            publish_stats.records,
+            publish_stats.keys,
+            publish_stats.remote_nodes,
+        ));
+        self.set_error(None);
+    }
+
     /// Everything the regular player shows, as DHT item specs: non-hidden
     /// artists, releases and tracks (a track also hides with its release).
     async fn collect_specs(&self) -> Result<Vec<ItemSpec>> {
         let pool = self.pool().await?;
         let mut specs = Vec::new();
 
-        let artists =
-            sqlx::query("SELECT id, name FROM furumusic__artist WHERE is_hidden = false")
-                .fetch_all(&pool)
-                .await?;
+        let artists = sqlx::query("SELECT id, name FROM furumusic__artist WHERE is_hidden = false")
+            .fetch_all(&pool)
+            .await?;
         for row in &artists {
             let id: i64 = row.get(0);
             specs.push(ItemSpec {
@@ -323,9 +360,14 @@ impl Federation {
                 kind: ItemKind::Artist,
                 name: row.get(1),
                 artist_names: Vec::new(),
+                featured_artist_names: Vec::new(),
                 year: None,
                 release_type: None,
+                release_title: None,
+                track_number: None,
+                disc_number: None,
                 duration_seconds: None,
+                content_id: None,
             });
         }
 
@@ -357,52 +399,100 @@ impl Federation {
                 kind: ItemKind::Release,
                 name: row.get(1),
                 artist_names: artists_of_release.remove(&id).unwrap_or_default(),
+                featured_artist_names: Vec::new(),
                 year: row.get(2),
                 release_type: row.get(3),
+                release_title: None,
+                track_number: None,
+                disc_number: None,
                 duration_seconds: None,
+                content_id: None,
             });
         }
 
         let track_artists = sqlx::query(
-            "SELECT ta.track_id, a.name FROM furumusic__track_artist ta
+            "SELECT ta.track_id, a.name, ta.role FROM furumusic__track_artist ta
              JOIN furumusic__artist a ON a.id = ta.artist_id
              WHERE ta.role IN ('main', 'featuring')
-             ORDER BY ta.track_id, ta.position",
+             ORDER BY ta.track_id,
+                      CASE ta.role WHEN 'main' THEN 0 ELSE 1 END,
+                      ta.position",
         )
         .fetch_all(&pool)
         .await?;
         let mut artists_of_track: std::collections::HashMap<i64, Vec<String>> = Default::default();
+        let mut featured_of_track: std::collections::HashMap<i64, Vec<String>> = Default::default();
         for row in &track_artists {
-            artists_of_track
-                .entry(row.get(0))
-                .or_default()
-                .push(row.get(1));
+            let id: i64 = row.get(0);
+            let name: String = row.get(1);
+            if row.get::<String, _>(2) == "featuring" {
+                featured_of_track.entry(id).or_default().push(name);
+            } else {
+                artists_of_track.entry(id).or_default().push(name);
+            }
         }
         let tracks = sqlx::query(
-            "SELECT t.id, t.title, COALESCE(t.year, r.year), t.duration_seconds
+            "SELECT t.id, t.title, COALESCE(t.year, r.year), t.duration_seconds,
+                    r.title, r.release_type, t.track_number, t.disc_number,
+                    t.audio_file_id, m.file_path, m.sha256_hash
              FROM furumusic__track t
              JOIN furumusic__release r ON r.id = t.release_id
+             JOIN furumusic__media_file m ON m.id = t.audio_file_id
              WHERE t.is_hidden = false AND r.is_hidden = false",
         )
         .fetch_all(&pool)
         .await?;
+        let storage_dir = lock(&self.storage_dir).clone();
         for row in &tracks {
             let id: i64 = row.get(0);
             let duration: f64 = row.get(3);
+            let media_file_id: i64 = row.get(8);
+            let file_path: String = row.get(9);
+            let sha256_hash: String = row.get(10);
+            let content_id = self
+                .content_id_for_media(media_file_id, sha256_hash, file_path, &storage_dir)
+                .await;
             specs.push(ItemSpec {
                 local_key: format!("track:{id}"),
                 kind: ItemKind::Track,
                 name: row.get(1),
                 artist_names: artists_of_track.remove(&id).unwrap_or_default(),
+                featured_artist_names: featured_of_track.remove(&id).unwrap_or_default(),
                 year: row.get(2),
-                release_type: None,
+                release_type: row.get(5),
+                release_title: Some(row.get(4)),
+                track_number: row.get(6),
+                disc_number: row.get(7),
                 duration_seconds: (duration > 0.0).then_some(duration),
+                content_id,
             });
         }
 
         Ok(specs)
     }
 
+    async fn content_id_for_media(
+        &self,
+        media_file_id: i64,
+        sha256_hash: String,
+        file_path: String,
+        storage_dir: &str,
+    ) -> Option<String> {
+        if let Some((cached_hash, content_id)) = lock(&self.content_cache).get(&media_file_id)
+            && cached_hash == &sha256_hash
+        {
+            return Some(content_id.clone());
+        }
+        let storage_dir = storage_dir.to_string();
+        let content_id =
+            tokio::task::spawn_blocking(move || audio_content_id(&storage_dir, &file_path))
+                .await
+                .ok()
+                .flatten()?;
+        lock(&self.content_cache).insert(media_file_id, (sha256_hash, content_id.clone()));
+        Some(content_id)
+    }
+
     /// Live status for the admin page.
     pub async fn status(&self) -> Value {
         let guard = self.running.lock().await;
@@ -460,6 +550,17 @@ impl Federation {
     }
 }
 
+fn audio_content_id(storage_dir: &str, file_path: &str) -> Option<String> {
+    if storage_dir.trim().is_empty() {
+        return None;
+    }
+    let path = crate::media_paths::resolve_media_file_path(storage_dir, file_path);
+    let mut file = std::fs::File::open(path).ok()?;
+    let mut hasher = blake3::Hasher::new();
+    std::io::copy(&mut file, &mut hasher).ok()?;
+    Some(format!("b3:{}", hasher.finalize().to_hex()))
+}
+
 async fn stop_running(running: Option<Running>) {
     let Some(running) = running else { return };
     for task in &running.tasks {

src/federation/serve.rs

@@ -101,6 +101,8 @@ struct CatalogTrack {
     track_number: Option<i32>,
     disc_number: Option<i32>,
     duration_seconds: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    content_id: Option<String>,
     item_id: String,
 }
 
@@ -150,7 +152,10 @@ async fn read_line<R: AsyncRead + Unpin>(reader: &mut R) -> Result<Vec<u8>> {
     }
 }
 
-async fn write_line<W: AsyncWriteExt + Unpin>(writer: &mut W, value: &impl Serialize) -> Result<()> {
+async fn write_line<W: AsyncWriteExt + Unpin>(
+    writer: &mut W,
+    value: &impl Serialize,
+) -> Result<()> {
     let mut line = serde_json::to_vec(value)?;
     line.push(b'\n');
     writer.write_all(&line).await?;
@@ -186,7 +191,10 @@ fn guess_mime(path: &Path) -> &'static str {
 }
 
 /// Reads an image media file from disk, bounded by [`MAX_IMAGE_BYTES`].
-async fn read_image(storage_dir: &str, media: Option<(String, String)>) -> Option<(Vec<u8>, String)> {
+async fn read_image(
+    storage_dir: &str,
+    media: Option<(String, String)>,
+) -> Option<(Vec<u8>, String)> {
     let (file_path, mime) = media?;
     let path = resolve_media_path(storage_dir, &file_path);
     let size = tokio::fs::metadata(&path).await.ok()?.len();
@@ -367,7 +375,9 @@ async fn serve_audio_one(
         Some(item_id) => match resolve_track_id(&pool, &own, item_id).await {
             Ok(Some(track_id)) => track_id,
             Ok(None) => return refuse_audio(stream, "track not found in the library").await,
-            Err(err) => return refuse_audio(stream, &format!("library lookup failed: {err:#}")).await,
+            Err(err) => {
+                return refuse_audio(stream, &format!("library lookup failed: {err:#}")).await;
+            }
         },
         None => return refuse_audio(stream, "malformed item_id").await,
     };
@@ -378,7 +388,9 @@ async fn serve_audio_one(
     let path = resolve_media_path(&storage_dir, &file_path);
     let mut file = match tokio::fs::File::open(&path).await {
         Ok(file) => file,
-        Err(err) => return refuse_audio(stream, &format!("audio file is not readable: {err}")).await,
+        Err(err) => {
+            return refuse_audio(stream, &format!("audio file is not readable: {err}")).await;
+        }
     };
     let total_size = file.metadata().await?.len();
     let offset = request.offset.min(total_size);
@@ -395,10 +407,17 @@ async fn serve_audio_one(
     };
     let (cover, artist_image) = if request.want_cover {
         (
-            read_image(&storage_dir, track_cover_file(&pool, track_id).await.ok().flatten()).await,
             read_image(
                 &storage_dir,
-                track_artist_image_file(&pool, track_id).await.ok().flatten(),
+                track_cover_file(&pool, track_id).await.ok().flatten(),
+            )
+            .await,
+            read_image(
+                &storage_dir,
+                track_artist_image_file(&pool, track_id)
+                    .await
+                    .ok()
+                    .flatten(),
             )
             .await,
         )
@@ -503,7 +522,7 @@ async fn serve_catalog_one(
 
     match request.want.as_deref() {
         None | Some("catalog") => {
-            let response = match build_catalog(&pool, &own, &request.artist).await {
+            let response = match build_catalog(&pool, &own, &storage_dir, &request.artist).await {
                 Ok(response) => response,
                 Err(err) => CatalogResponse {
                     ok: false,
@@ -511,7 +530,10 @@ async fn serve_catalog_one(
                     artist: None,
                 },
             };
-            stream.send.write_all(&serde_json::to_vec(&response)?).await?;
+            stream
+                .send
+                .write_all(&serde_json::to_vec(&response)?)
+                .await?;
         }
         Some(want @ ("artist_image" | "release_cover")) => {
             let media = if want == "release_cover" {
@@ -549,7 +571,10 @@ async fn serve_catalog_one(
                 error: Some(format!("unknown request kind '{other}'")),
                 artist: None,
             };
-            stream.send.write_all(&serde_json::to_vec(&response)?).await?;
+            stream
+                .send
+                .write_all(&serde_json::to_vec(&response)?)
+                .await?;
         }
     }
     stream.send.finish()?;
@@ -557,7 +582,12 @@ async fn serve_catalog_one(
     Ok(())
 }
 
-async fn build_catalog(pool: &PgPool, own: &EndpointId, artist: &str) -> Result<CatalogResponse> {
+async fn build_catalog(
+    pool: &PgPool,
+    own: &EndpointId,
+    storage_dir: &str,
+    artist: &str,
+) -> Result<CatalogResponse> {
     let Some(artist_row) = sqlx::query(
         "SELECT id, name FROM furumusic__artist
          WHERE LOWER(name) = LOWER($1) AND is_hidden = false
@@ -589,32 +619,36 @@ async fn build_catalog(pool: &PgPool, own: &EndpointId, artist: &str) -> Result<
     for release_row in release_rows {
         let release_id: i64 = release_row.get(0);
         let track_rows = sqlx::query(
-            "SELECT id, title, track_number, disc_number, duration_seconds
-             FROM furumusic__track
-             WHERE release_id = $1 AND is_hidden = false
-             ORDER BY disc_number NULLS FIRST, track_number NULLS LAST, title",
+            "SELECT t.id, t.title, t.track_number, t.disc_number, t.duration_seconds,
+                    m.file_path
+             FROM furumusic__track t
+             JOIN furumusic__media_file m ON m.id = t.audio_file_id
+             WHERE t.release_id = $1 AND t.is_hidden = false
+             ORDER BY t.disc_number NULLS FIRST, t.track_number NULLS LAST, t.title",
         )
         .bind(release_id)
         .fetch_all(pool)
         .await?;
+        let mut tracks = Vec::with_capacity(track_rows.len());
+        for row in track_rows {
+            let track_id: i64 = row.get(0);
+            let duration: f64 = row.get(4);
+            let file_path: String = row.get(5);
+            let content_id = catalog_content_id(storage_dir, file_path).await;
+            tracks.push(CatalogTrack {
+                title: row.get(1),
+                track_number: row.get(2),
+                disc_number: row.get(3),
+                duration_seconds: (duration > 0.0).then_some(duration),
+                content_id,
+                item_id: item_id_of(own, track_id),
+            });
+        }
         releases.push(CatalogRelease {
             title: release_row.get(1),
             release_type: release_row.get(2),
             year: release_row.get(3),
-            tracks: track_rows
-                .into_iter()
-                .map(|row| {
-                    let track_id: i64 = row.get(0);
-                    let duration: f64 = row.get(4);
-                    CatalogTrack {
-                        title: row.get(1),
-                        track_number: row.get(2),
-                        disc_number: row.get(3),
-                        duration_seconds: (duration > 0.0).then_some(duration),
-                        item_id: item_id_of(own, track_id),
-                    }
-                })
-                .collect(),
+            tracks,
         });
     }
 
@@ -628,6 +662,14 @@ async fn build_catalog(pool: &PgPool, own: &EndpointId, artist: &str) -> Result<
     })
 }
 
+async fn catalog_content_id(storage_dir: &str, file_path: String) -> Option<String> {
+    let storage_dir = storage_dir.to_string();
+    tokio::task::spawn_blocking(move || super::audio_content_id(&storage_dir, &file_path))
+        .await
+        .ok()
+        .flatten()
+}
+
 async fn artist_image_by_name(pool: &PgPool, artist: &str) -> Result<Option<(String, String)>> {
     let row = sqlx::query(
         "SELECT m.file_path, m.mime_type FROM furumusic__artist a

src/main.rs

@@ -3,6 +3,7 @@ mod agent;
 mod api;
 mod auth;
 mod config;
+mod federation;
 mod i18n;
 mod jobs;
 mod lastfm;
@@ -12,7 +13,6 @@ mod music;
 mod oidc;
 mod player;
 mod scheduler;
-mod federation;
 mod torrents;
 mod user;