Move the files around

crates/musicfs-cache/src/metadata.rs

@@ -0,0 +1,138 @@
+use crate::db::Database;
+use musicfs_core::{AudioMeta, FileMeta, OriginId, Result, VirtualPath};
+use std::path::Path;
+use std::sync::Arc;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use tracing::trace;
+
+pub struct MetadataCache {
+    db: Arc<Database>,
+}
+
+impl MetadataCache {
+    pub fn new(db: Arc<Database>) -> Self {
+        Self { db }
+    }
+
+    pub fn store(
+        &self,
+        origin_id: &OriginId,
+        real_path: &Path,
+        virtual_path: &VirtualPath,
+        audio_meta: &AudioMeta,
+        origin_mtime: SystemTime,
+        origin_size: u64,
+    ) -> Result<()> {
+        self.db.upsert_file(
+            origin_id,
+            real_path,
+            virtual_path,
+            audio_meta,
+            origin_mtime,
+            origin_size,
+        )?;
+        Ok(())
+    }
+
+    pub fn lookup(&self, path: &VirtualPath) -> Result<Option<FileMeta>> {
+        let result = self.db.get_file_by_virtual_path(path)?;
+        let hit = result.is_some();
+        trace!(path = path.as_str(), hit, "metadata cache lookup");
+        Ok(result)
+    }
+
+    pub fn is_fresh(
+        &self,
+        origin_id: &OriginId,
+        real_path: &Path,
+        current_mtime: SystemTime,
+    ) -> Result<bool> {
+        if let Some(cached_mtime) = self.db.get_mtime_by_real_path(origin_id, real_path)? {
+            let current_secs = current_mtime
+                .duration_since(UNIX_EPOCH)
+                .unwrap_or(Duration::ZERO)
+                .as_secs();
+            let cached_secs = cached_mtime
+                .duration_since(UNIX_EPOCH)
+                .unwrap_or(Duration::ZERO)
+                .as_secs();
+            let hit = current_secs == cached_secs;
+            trace!(path = ?real_path, hit, "metadata freshness check");
+            Ok(hit)
+        } else {
+            trace!(path = ?real_path, hit = false, "metadata freshness check");
+            Ok(false)
+        }
+    }
+
+    pub fn invalidate(&self, path: &VirtualPath) -> Result<()> {
+        if let Some(meta) = self.db.get_file_by_virtual_path(path)? {
+            self.db.delete_file(meta.id)?;
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use musicfs_core::AudioFormat;
+
+    #[test]
+    fn test_metadata_cache_store_and_lookup() {
+        let db = Arc::new(Database::open_memory().unwrap());
+        let cache = MetadataCache::new(db);
+
+        let origin_id = OriginId::from("local");
+        let real_path = Path::new("/music/song.flac");
+        let virtual_path = VirtualPath::new("/Artist/Album/Song.flac");
+        let meta = AudioMeta {
+            title: Some("Song".to_string()),
+            artist: Some("Artist".to_string()),
+            format: AudioFormat::Flac,
+            ..Default::default()
+        };
+
+        cache
+            .store(
+                &origin_id,
+                real_path,
+                &virtual_path,
+                &meta,
+                UNIX_EPOCH,
+                5000,
+            )
+            .unwrap();
+
+        let retrieved = cache.lookup(&virtual_path).unwrap().unwrap();
+        assert_eq!(
+            retrieved.audio.as_ref().unwrap().title,
+            Some("Song".to_string())
+        );
+    }
+
+    #[test]
+    fn test_metadata_cache_invalidate() {
+        let db = Arc::new(Database::open_memory().unwrap());
+        let cache = MetadataCache::new(db);
+
+        let virtual_path = VirtualPath::new("/Test.flac");
+
+        cache
+            .store(
+                &OriginId::from("local"),
+                Path::new("/test.flac"),
+                &virtual_path,
+                &AudioMeta::default(),
+                UNIX_EPOCH,
+                100,
+            )
+            .unwrap();
+
+        assert!(cache.lookup(&virtual_path).unwrap().is_some());
+
+        cache.invalidate(&virtual_path).unwrap();
+
+        assert!(cache.lookup(&virtual_path).unwrap().is_none());
+    }
+}