Track media server songs list

src/daemon/mod.rs

@@ -0,0 +1,5 @@
+pub mod update_playlists;
+pub mod update_tracks;
+
+pub use update_playlists::update_playlists_daemon;
+pub use update_tracks::update_tracks_daemon;

src/daemon/update_playlists.rs

@@ -5,6 +5,8 @@ use std::time::Duration;
 use tokio::time::{interval, MissedTickBehavior};
 
 pub async fn update_playlists_daemon() -> Result<(), Box<dyn std::error::Error>> {
+    println!("Playlist daemon starting...");
+
     let database = PgPool::connect(&env::var("DATABASE_URL").unwrap())
         .await
         .unwrap();

src/daemon/update_tracks.rs

@@ -0,0 +1,33 @@
+use navidrome::{
+    client::{library::Library, Navidrome},
+    models::navidrome::NavidromeTrack,
+};
+
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::sync::RwLock;
+use tokio::time::{interval, MissedTickBehavior};
+
+pub async fn update_tracks_daemon(
+    media_client: &Navidrome,
+    tracks_map: &mut Arc<RwLock<HashMap<String, NavidromeTrack>>>,
+) -> Result<(), Box<dyn std::error::Error>> {
+    println!("Tracks daemon starting...");
+
+    let mut ticker = interval(Duration::from_secs(30));
+    ticker.set_missed_tick_behavior(MissedTickBehavior::Skip);
+
+    loop {
+        let mut tracks_map = tracks_map.write().await;
+        media_client.tracks().await?.iter().for_each(|t| {
+            if let Some(mb_id) = &t.musicbrainz_track_id {
+                tracks_map.insert(mb_id.clone(), t.clone());
+            }
+        });
+
+        println!("Found {} tracks", tracks_map.len());
+
+        ticker.tick().await;
+    }
+}

src/main.rs

@@ -2,20 +2,54 @@ mod daemon;
 mod listenbrainz;
 mod models;
 
-use crate::daemon::update_playlists_daemon;
+use navidrome::{
+    client::{builder::NavidromeBuilder, library::Library},
+    models::navidrome::NavidromeTrack,
+};
+
+use crate::daemon::{update_playlists_daemon, update_tracks_daemon};
 use crate::listenbrainz::StatsRange;
 use axum::extract::State;
 use axum::routing::get;
 use axum::Router;
 use sqlx::postgres::PgPool;
+use std::collections::HashMap;
 use std::env;
 use std::net::SocketAddr;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+
+#[derive(Clone)]
+struct TrackState {
+    tracks: Arc<RwLock<HashMap<String, NavidromeTrack>>>,
+}
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let database = PgPool::connect(&env::var("DATABASE_URL")?).await?;
     sqlx::migrate!().run(&database).await?;
 
+    let media_client = NavidromeBuilder::new()
+        .base(env::var("NAVIDROME_BASE")?)
+        .token(env::var("NAVIDROME_TOKEN")?)
+        .build()?;
+
+    let mut tracks = Arc::new(RwLock::new(HashMap::new()));
+
+    let state = TrackState {
+        tracks: tracks.clone(),
+    };
+
+    tokio::spawn(async move {
+        update_playlists_daemon().await.unwrap();
+    });
+
+    tokio::spawn(async move {
+        update_tracks_daemon(&media_client, &mut tracks)
+            .await
+            .unwrap();
+    });
+
     let app = Router::new().route("/", get(index)).with_state(database);
 
     let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
@@ -23,10 +57,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .serve(app.into_make_service())
         .await?;
 
-    tokio::spawn(async move {
-        update_playlists_daemon().await.unwrap();
-    });
-
     Ok(())
 }