use anyhow::Result;
use std::path::Path;
use tokio::fs;
use crate::fingerprint::models::{FingerprintMetadata, FingerprintRuleset};
pub(crate) async fn load_from_cache(
cache_dir: &Path,
cache_key: &str,
expected_sources: &str,
) -> Result<FingerprintRuleset> {
let cache_subdir = cache_dir.join(cache_key);
let metadata_path = cache_subdir.join("metadata.json");
let technologies_path = cache_subdir.join("technologies.json");
let categories_path = cache_subdir.join("categories.json");
if !metadata_path.exists() || !technologies_path.exists() {
return Err(anyhow::anyhow!(
"Cache not found at {} for sources: {}",
cache_subdir.display(),
expected_sources
));
}
let metadata_json = fs::read_to_string(&metadata_path).await?;
let metadata: FingerprintMetadata = serde_json::from_str(&metadata_json)?;
if metadata.source != expected_sources {
return Err(anyhow::anyhow!(
"Cache source mismatch: expected '{}', got '{}'",
expected_sources,
metadata.source
));
}
if crate::utils::cache::cache_ttl_exceeded(
metadata.last_updated,
crate::config::FINGERPRINT_CACHE_TTL_SECS,
false,
) {
return Err(anyhow::anyhow!(
"Cache expired for sources: {expected_sources}"
));
}
let technologies_json = fs::read_to_string(&technologies_path).await?;
let technologies: std::collections::HashMap<String, crate::fingerprint::models::Technology> =
serde_json::from_str(&technologies_json)?;
let categories = if categories_path.exists() {
match fs::read_to_string(&categories_path).await {
Ok(categories_json) => {
match serde_json::from_str::<std::collections::HashMap<u32, String>>(
&categories_json,
) {
Ok(cats) => {
log::debug!("Loaded {} categories from cache", cats.len());
cats
}
Err(e) => {
log::warn!("Failed to parse categories from cache: {e}");
std::collections::HashMap::new()
}
}
}
Err(e) => {
log::warn!("Failed to read categories from cache: {e}");
std::collections::HashMap::new()
}
}
} else {
log::debug!("Categories cache not found, using empty map");
std::collections::HashMap::new()
};
Ok(FingerprintRuleset {
technologies,
categories,
metadata,
})
}
pub(crate) async fn save_to_cache(
ruleset: &FingerprintRuleset,
cache_dir: &Path,
cache_key: &str,
) -> Result<()> {
let cache_subdir = cache_dir.join(cache_key);
fs::create_dir_all(&cache_subdir).await?;
let metadata_path = cache_subdir.join("metadata.json");
let technologies_path = cache_subdir.join("technologies.json");
let categories_path = cache_subdir.join("categories.json");
let metadata_json = serde_json::to_string_pretty(&ruleset.metadata)?;
crate::utils::cache::write_atomic(&metadata_path, metadata_json.as_bytes()).await?;
let technologies_json = serde_json::to_string_pretty(&ruleset.technologies)?;
crate::utils::cache::write_atomic(&technologies_path, technologies_json.as_bytes()).await?;
let categories_json = serde_json::to_string_pretty(&ruleset.categories)?;
crate::utils::cache::write_atomic(&categories_path, categories_json.as_bytes()).await?;
prune_superseded_fingerprint_dirs(cache_dir, cache_key).await;
Ok(())
}
async fn prune_superseded_fingerprint_dirs(cache_dir: &Path, keep_key: &str) {
let Ok(mut entries) = fs::read_dir(cache_dir).await else {
return;
};
while let Ok(Some(entry)) = entries.next_entry().await {
let path = entry.path();
if !path.is_dir() {
continue;
}
let Some(name) = path.file_name().and_then(|s| s.to_str()) else {
continue;
};
if name == keep_key {
continue;
}
match fs::remove_dir_all(&path).await {
Ok(()) => log::debug!("Pruned superseded fingerprint cache dir {}", path.display()),
Err(e) => log::warn!(
"Failed to prune fingerprint cache dir {}: {e}",
path.display()
),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::time::SystemTime;
use tempfile::TempDir;
fn create_test_ruleset(source: &str) -> FingerprintRuleset {
FingerprintRuleset {
technologies: std::collections::HashMap::new(),
categories: std::collections::HashMap::new(),
metadata: FingerprintMetadata {
source: source.to_string(),
version: "test".to_string(),
last_updated: SystemTime::now(),
},
}
}
#[tokio::test]
async fn test_load_from_cache_not_found() {
let temp_dir = TempDir::new().expect("Failed to create temp directory");
let cache_key = "test-hash";
let result = load_from_cache(temp_dir.path(), cache_key, "test-source").await;
assert!(result.is_err());
let error_msg = result.unwrap_err().to_string();
assert!(
error_msg.contains("Cache not found"),
"Expected cache not found error, got: {}",
error_msg
);
}
#[tokio::test]
async fn test_load_from_cache_source_mismatch() {
let temp_dir = TempDir::new().expect("Failed to create temp directory");
let cache_dir = temp_dir.path();
let cache_key = "test-hash";
let ruleset = create_test_ruleset("source1");
save_to_cache(&ruleset, cache_dir, cache_key)
.await
.expect("Failed to save cache");
let result = load_from_cache(cache_dir, cache_key, "source2").await;
assert!(result.is_err());
let error_msg = result.unwrap_err().to_string();
assert!(
error_msg.contains("source mismatch"),
"Expected source mismatch error, got: {}",
error_msg
);
}
#[tokio::test]
async fn test_load_from_cache_expired() {
let temp_dir = TempDir::new().expect("Failed to create temp directory");
let cache_dir = temp_dir.path();
let cache_key = "test-hash";
let cache_subdir = cache_dir.join(cache_key);
tokio::fs::create_dir_all(&cache_subdir)
.await
.expect("Failed to create cache subdirectory");
let expired_metadata = FingerprintMetadata {
source: "test-source".to_string(),
version: "test".to_string(),
last_updated: SystemTime::now() - std::time::Duration::from_secs(7 * 24 * 60 * 60 + 1), };
let metadata_path = cache_subdir.join("metadata.json");
let metadata_json = serde_json::to_string_pretty(&expired_metadata).unwrap();
tokio::fs::write(&metadata_path, metadata_json)
.await
.expect("Failed to write metadata");
let technologies_path = cache_subdir.join("technologies.json");
tokio::fs::write(&technologies_path, "{}")
.await
.expect("Failed to write technologies");
let result = load_from_cache(cache_dir, cache_key, "test-source").await;
assert!(result.is_err());
let error_msg = result.unwrap_err().to_string();
assert!(
error_msg.contains("expired"),
"Expected expired cache error, got: {}",
error_msg
);
}
#[tokio::test]
async fn test_save_and_load_from_cache_round_trip() {
let temp_dir = TempDir::new().expect("Failed to create temp directory");
let cache_dir = temp_dir.path();
let cache_key = "test-hash";
let ruleset = create_test_ruleset("test-source");
save_to_cache(&ruleset, cache_dir, cache_key)
.await
.expect("Failed to save cache");
let loaded = load_from_cache(cache_dir, cache_key, "test-source")
.await
.expect("Failed to load cache");
assert_eq!(loaded.metadata.source, ruleset.metadata.source);
assert_eq!(loaded.metadata.version, ruleset.metadata.version);
}
#[tokio::test]
async fn test_load_from_cache_missing_categories() {
let temp_dir = TempDir::new().expect("Failed to create temp directory");
let cache_dir = temp_dir.path();
let cache_key = "test-hash";
let ruleset = create_test_ruleset("test-source");
save_to_cache(&ruleset, cache_dir, cache_key)
.await
.expect("Failed to save cache");
let cache_subdir = cache_dir.join(cache_key);
let categories_path = cache_subdir.join("categories.json");
let _ = tokio::fs::remove_file(&categories_path).await;
let loaded = load_from_cache(cache_dir, cache_key, "test-source")
.await
.expect("Failed to load cache");
assert!(loaded.categories.is_empty());
}
#[tokio::test]
async fn test_load_from_cache_invalid_metadata_json() {
let temp_dir = TempDir::new().expect("Failed to create temp directory");
let cache_dir = temp_dir.path();
let cache_key = "test-hash";
let cache_subdir = cache_dir.join(cache_key);
tokio::fs::create_dir_all(&cache_subdir)
.await
.expect("Failed to create cache subdirectory");
let metadata_path = cache_subdir.join("metadata.json");
tokio::fs::write(&metadata_path, b"{ invalid json }")
.await
.expect("Failed to write invalid metadata");
let technologies_path = cache_subdir.join("technologies.json");
tokio::fs::write(&technologies_path, "{}")
.await
.expect("Failed to write technologies");
let result = load_from_cache(cache_dir, cache_key, "test-source").await;
assert!(result.is_err());
let error_msg = result.unwrap_err().to_string();
assert!(
error_msg.contains("parse")
|| error_msg.contains("JSON")
|| error_msg.contains("key must be a string")
|| error_msg.contains("invalid"),
"Expected JSON parse error, got: {}",
error_msg
);
}
#[tokio::test]
async fn test_load_from_cache_merged_source() {
let temp_dir = TempDir::new().expect("Failed to create temp directory");
let cache_dir = temp_dir.path();
let cache_key = "merged-hash";
let merged_sources = "url1\nurl2";
let ruleset = create_test_ruleset(merged_sources);
save_to_cache(&ruleset, cache_dir, cache_key)
.await
.expect("Failed to save cache");
let loaded = load_from_cache(cache_dir, cache_key, merged_sources)
.await
.expect("Failed to load cache");
assert_eq!(loaded.metadata.source, merged_sources);
}
#[tokio::test]
async fn test_save_to_cache_creates_directory() {
let temp_dir = TempDir::new().expect("Failed to create temp directory");
let cache_dir = temp_dir.path().join("nested").join("cache");
let cache_key = "test-hash";
let ruleset = create_test_ruleset("test-source");
let result = save_to_cache(&ruleset, &cache_dir, cache_key).await;
assert!(result.is_ok());
let cache_subdir = cache_dir.join(cache_key);
assert!(cache_subdir.join("metadata.json").exists());
assert!(cache_subdir.join("technologies.json").exists());
assert!(cache_subdir.join("categories.json").exists());
}
#[tokio::test]
async fn test_save_to_cache_prunes_superseded_hash_dirs() {
let temp_dir = TempDir::new().expect("Failed to create temp directory");
let cache_dir = temp_dir.path();
let old = create_test_ruleset("old-source");
save_to_cache(&old, cache_dir, "old-hash")
.await
.expect("save old");
assert!(cache_dir.join("old-hash").exists());
let new = create_test_ruleset("new-source");
save_to_cache(&new, cache_dir, "new-hash")
.await
.expect("save new");
assert!(cache_dir.join("new-hash").exists());
assert!(
!cache_dir.join("old-hash").exists(),
"superseded fingerprint hash dir should be pruned"
);
}
}