Files
Thing/src-tauri/src/music/feiniu/cache.rs
T
2026-09-15 17:17:16 +08:00

163 lines
5.2 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 飞牛音乐播放缓存(容量限制 + LRU 逐出)。
//!
//! 缓存目录:`{app_data}/music/cache`,文件 `guid.<ext>`(ext 缺省记 `bin`)。
//! 元数据:`index.json` → `{ "guid": { "size", "lastUsed", "file" } }`。
//! 超上限按 lastUsed 升序逐出,直到总占用低于上限。
use std::collections::HashMap;
use std::fs;
use std::io::Write;
use std::path::{Path, PathBuf};
use std::time::{SystemTime, UNIX_EPOCH};
use serde::{Deserialize, Serialize};
use serde_json::json;
/// 单条缓存元数据
#[derive(Serialize, Deserialize, Clone)]
pub struct CacheEntry {
pub size: u64,
pub last_used: u64,
pub file: String,
}
pub struct CacheManager {
root: PathBuf,
index_path: PathBuf,
}
impl CacheManager {
pub fn new(app_data_dir: &Path) -> Self {
let root = app_data_dir.join("music").join("cache");
fs::create_dir_all(&root).ok();
let index_path = root.join("index.json");
Self { root, index_path }
}
/// 本地曲库标签缓存文件:{cache_root}/local-tags.json。
/// 记录 path -> {size, mtim, 标签},扫描时未变化的文件直接复用,
/// 避免万级曲库每次都重新解析音频标签。
pub fn local_tags_path(&self) -> PathBuf {
self.root.join("local-tags.json")
}
fn load_index(&self) -> HashMap<String, CacheEntry> {
fs::read_to_string(&self.index_path)
.ok()
.and_then(|s| serde_json::from_str(&s).ok())
.unwrap_or_default()
}
fn save_index(&self, idx: &HashMap<String, CacheEntry>) {
if let Ok(s) = serde_json::to_string(idx) {
fs::write(&self.index_path, s).ok();
}
}
fn now_ms(&self) -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_millis() as u64)
.unwrap_or(0)
}
/// 命中缓存:更新 lastUsed 并返回文件路径。
pub fn hit(&self, guid: &str) -> Option<String> {
let mut idx = self.load_index();
if let Some(e) = idx.get_mut(guid) {
let path = self.root.join(&e.file);
if path.exists() {
e.last_used = self.now_ms();
self.save_index(&idx);
return Some(path.to_string_lossy().to_string());
}
idx.remove(guid);
self.save_index(&idx);
}
None
}
/// 写入缓存(流式 chunk);按上限(GB)逐出。返回写入总字节数。
pub async fn put<E: std::fmt::Display>(
&self,
guid: &str,
ext: &str,
max_gb: u32,
mut stream: impl futures_util::Stream<Item = Result<bytes::Bytes, E>> + Unpin,
) -> Result<u64, String> {
let safe_guid = sanitize(guid);
let ext = if ext.is_empty() { "bin" } else { ext };
let file = format!("{safe_guid}.{ext}");
let path = self.root.join(&file);
let mut total: u64 = 0;
let mut f = fs::File::create(&path).map_err(|e| format!("创建缓存文件失败: {e}"))?;
while let Some(chunk) = futures_util::StreamExt::next(&mut stream).await {
let chunk = chunk.map_err(|e| format!("读取流失败: {e}"))?;
total += chunk.len() as u64;
f.write_all(chunk.as_ref()).map_err(|e| format!("写入缓存失败: {e}"))?;
}
f.flush().ok();
let mut idx = self.load_index();
idx.insert(
guid.to_string(),
CacheEntry {
size: total,
last_used: self.now_ms(),
file,
},
);
self.save_index(&idx);
self.evict(max_gb);
Ok(total)
}
/// 按上限(GB)逐出。max_gb==0 视为全部清空。
fn evict(&self, max_gb: u32) {
if max_gb == 0 {
self.clear();
return;
}
let max_bytes = max_gb as u64 * 1024 * 1024 * 1024;
let mut idx = self.load_index();
let mut total: u64 = idx.values().map(|e| e.size).sum();
let mut order: Vec<(String, u64)> = idx.iter().map(|(g, e)| (g.clone(), e.last_used)).collect();
order.sort_by_key(|(_, t)| *t);
for (guid, _) in order {
if total <= max_bytes {
break;
}
if let Some(e) = idx.remove(&guid) {
let _ = fs::remove_file(self.root.join(&e.file));
total = total.saturating_sub(e.size);
}
}
self.save_index(&idx);
}
/// 当前占用与条目数。
pub fn status(&self) -> serde_json::Value {
let idx = self.load_index();
let total: u64 = idx.values().map(|e| e.size).sum();
json!({
"count": idx.len(),
"usedBytes": total,
"usedMb": (total as f64 / 1024.0 / 1024.0 * 10.0).round() / 10.0,
})
}
pub fn clear(&self) {
let idx = self.load_index();
for e in idx.values() {
let _ = fs::remove_file(self.root.join(&e.file));
}
fs::remove_file(&self.index_path).ok();
}
}
fn sanitize(s: &str) -> String {
s.chars()
.map(|c| if c.is_ascii_alphanumeric() || c == '-' || c == '_' { c } else { '_' })
.collect()
}