refactor: Move DB code to a DB crate.

Author: ccgauche

Cargo.lock

@@ -1,7 +1,8 @@
 [workspace]
 resolver = "3"
-members = ["crates/player", "crates/ytermusic", "crates/ytpapi2"]
+members = ["crates/database","crates/player", "crates/ytermusic", "crates/ytpapi2"]
 
 [workspace.dependencies]
 player = { path = "crates/player" }
-ytpapi2 = { path = "crates/ytpapi2" }
+ytpapi2 = { path = "crates/ytpapi2" }
+database = { path = "crates/database" }

Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "database"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+varuint = "0.7.1"
+ytpapi2.workspace = true
+log = "*"
+serde_json = "1.0.114"

crates/database/Cargo.toml

@@ -0,0 +1,42 @@
+use std::{fs::OpenOptions, path::PathBuf, sync::RwLock};
+
+mod reader;
+mod writer;
+
+pub use writer::write_video;
+use ytpapi2::YoutubeMusicVideoRef;
+
+pub struct YTLocalDatabase {
+    cache_dir: PathBuf,
+    references: RwLock<Vec<YoutubeMusicVideoRef>>,
+}
+
+impl YTLocalDatabase {
+    pub fn new(cache_dir: PathBuf) -> Self {
+        Self {
+            cache_dir,
+            references: RwLock::new(Vec::new()),
+        }
+    }
+
+    pub fn clone_from(&self, videos: &Vec<YoutubeMusicVideoRef>) {
+        self.references.write().unwrap().clone_from(videos);
+    }
+
+    pub fn remove_video(&self, video: &YoutubeMusicVideoRef) {
+        let mut database = self.references.write().unwrap();
+        database.retain(|v| v.video_id != video.video_id);
+        drop(database);
+        self.write();
+    }
+
+    pub fn append(&self, video: YoutubeMusicVideoRef) {
+        let mut file = OpenOptions::new()
+            .append(true)
+            .create(true)
+            .open(self.cache_dir.join("db.bin"))
+            .unwrap();
+        write_video(&mut file, &video);
+        self.references.write().unwrap().push(video);
+    }
+}

crates/database/src/lib.rs

@@ -3,16 +3,17 @@ use std::io::{Cursor, Read};
 use varuint::ReadVarint;
 use ytpapi2::YoutubeMusicVideoRef;
 
-use crate::consts::CACHE_DIR;
+use crate::YTLocalDatabase;
 
-/// Reads the database
-pub fn read() -> Option<Vec<YoutubeMusicVideoRef>> {
-    let mut buffer = Cursor::new(std::fs::read(CACHE_DIR.join("db.bin")).ok()?);
-    let mut videos = Vec::new();
-    while buffer.get_mut().len() > buffer.position() as usize {
-        videos.push(read_video(&mut buffer)?);
+impl YTLocalDatabase {
+    pub fn read(&self) -> Option<Vec<YoutubeMusicVideoRef>> {
+        let mut buffer = Cursor::new(std::fs::read(self.cache_dir.join("db.bin")).ok()?);
+        let mut videos = Vec::new();
+        while buffer.get_mut().len() > buffer.position() as usize {
+            videos.push(read_video(&mut buffer)?);
+        }
+        Some(videos)
     }
-    Some(videos)
 }
 
 /// Reads a video from the cursor

crates/ytermusic/src/database/reader.rs crates/database/src/reader.rscrates/ytermusic/src/database/reader.rs renamed to crates/database/src/reader.rs

@@ -0,0 +1,147 @@
+use std::{fs::OpenOptions, io::Write};
+
+use varuint::WriteVarint;
+use ytpapi2::YoutubeMusicVideoRef;
+
+use crate::YTLocalDatabase;
+
+impl YTLocalDatabase {
+    pub fn write(&self) {
+        let db = self.references.read().unwrap();
+        let mut file = OpenOptions::new()
+            .write(true)
+            .append(false)
+            .create(true)
+            .truncate(true)
+            .open(self.cache_dir.join("db.bin"))
+            .unwrap();
+        for video in db.iter() {
+            write_video(&mut file, video)
+        }
+    }
+}
+impl YTLocalDatabase {
+    pub fn fix_db(&self) {
+        let mut db = self.references.write().unwrap();
+        db.clear();
+        let cache_folder = self.cache_dir.join("downloads");
+        if !cache_folder.is_dir() {
+            println!(
+                "[WARN] The download folder in the cache wasn't found ({:?})",
+                cache_folder
+            );
+            return;
+        }
+        for entry in std::fs::read_dir(&cache_folder).unwrap() {
+            let entry = entry.unwrap();
+            let path = entry.path();
+            // Check if the file is a json file (+ sloppy check if there is any files or directory)
+            if path.extension().unwrap_or_default() != "json" {
+                continue;
+            }
+            // Read the file if not readable do not add it to the database
+            let content = match std::fs::read_to_string(&path) {
+                Ok(content) => content,
+                Err(e) => {
+                    match std::fs::remove_file(&path) {
+                        Ok(_) => println!(
+                            "[INFO] Removing file {:?} because the file is not readable: {e:?}",
+                            path.file_name()
+                        ),
+                        Err(ef) => println!(
+                            "[ERROR] file {:?} is not readable: {e:?}, but could not be deleted: {ef:?}",
+                            path.file_name()
+                        ),
+                    }
+                    continue;
+                }
+            };
+            // Check if the file is a valid json file
+            let video = match serde_json::from_str::<YoutubeMusicVideoRef>(&content) {
+                Ok(parsed) => parsed,
+                Err(e) => {
+                    match std::fs::remove_file(&path) {
+                        Ok(_) => println!(
+                            "[INFO] Removing file {:?} because the file is not a valid json file: {e:?}",
+                            path.file_name()
+                        ),
+                        Err(ef) => println!(
+                            "[ERROR] file {:?} is not a valid json file: {e:?}, but could not be deleted: {ef:?}",
+                            path.file_name()
+                        ),
+                    }
+                    continue;
+                }
+            };
+            // Check if the video file exists
+            let video_file = cache_folder.join(format!("{}.mp4", video.video_id));
+            if !video_file.exists() {
+                match std::fs::remove_file(&path) {
+                    Ok(_) => println!(
+                        "[INFO] Removing file {:?} because the video file does not exist",
+                        path.file_name()
+                    ),
+                    Err(ef) => println!(
+                        "[ERROR] video assocated to file {:?} does not exist, but the file could not be deleted: {ef:?}",
+                        path.file_name()
+                    ),
+                }
+                continue;
+            }
+            // Read the video file
+            let video_file = match std::fs::read(&video_file) {
+                Ok(video_file) => video_file,
+                Err(e) => {
+                    match std::fs::remove_file(&path) {
+                        Ok(_) => println!(
+                            "[INFO] Removing file {:?} because the video file is not readable: {e:?}",
+                            path.file_name()
+                        ),
+                        Err(ef) => println!(
+                            "[ERROR] video associated to file {:?} is not readable: {e:?}, but the file could not be deleted: {ef:?}",
+                            path.file_name()
+                        ),
+                    }
+                    continue;
+                }
+            };
+            // Check if the video file contains the header
+            if !video_file.starts_with(&[
+                0, 0, 0, 24, 102, 116, 121, 112, 100, 97, 115, 104, 0, 0, 0, 0,
+            ]) {
+                match std::fs::remove_file(&path) {
+                    Ok(_) => println!(
+                        "[INFO] Removing file {:?} because the video file does not contain the header",
+                        path.file_name()
+                    ),
+                    Err(ef) => println!(
+                        "[ERROR] video associated to file {:?} does not contain the header, but the file could not be deleted: {ef:?}",
+                        path.file_name()
+                    ),
+                }
+                continue;
+            }
+            db.push(video);
+        }
+    }
+}
+
+/// Writes a video to a file
+pub fn write_video(buffer: &mut impl Write, video: &YoutubeMusicVideoRef) {
+    write_str(buffer, &video.title);
+    write_str(buffer, &video.author);
+    write_str(buffer, &video.album);
+    write_str(buffer, &video.video_id);
+    write_str(buffer, &video.duration);
+}
+
+/// Writes a string from the cursor
+fn write_str(cursor: &mut impl Write, value: &str) {
+    write_u32(cursor, value.len() as u32);
+    cursor.write_all(value.as_bytes()).unwrap();
+}
+
+/// Writes a u32 from the cursor
+fn write_u32(cursor: &mut impl Write, value: u32) {
+    cursor.write_varint(value).unwrap();
+}

crates/database/src/writer.rs

@@ -44,6 +44,9 @@ toml = "0.8.11"
 #  --- Logging ---
 log = "0.4.21"
 
+#  --- Database ---
+database.workspace = true
+
 # -- Cookies auto retreival --
 rookie = "0.5.2"
 

crates/ytermusic/Cargo.toml

@@ -0,0 +1,6 @@
+use database::YTLocalDatabase;
+use once_cell::sync::Lazy;
+
+use crate::consts::CACHE_DIR;
+
+pub static DATABASE: Lazy<YTLocalDatabase> = Lazy::new(|| YTLocalDatabase::new(CACHE_DIR.clone()));