use anyhow::{Context, Result};
use redb::{Database, ReadableDatabase, TableDefinition};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use std::collections::HashMap;
use std::fs;
use std::path::{Path, PathBuf};
use std::sync::Mutex;
use std::time::SystemTime;
const MTIME_TABLE: TableDefinition<&str, &[u8]> = TableDefinition::new("mtime_cache");
#[derive(Serialize, Deserialize)]
struct MtimeEntry {
mtime_secs: i64,
mtime_nanos: u32,
checksum: String,
}
static CACHE: Mutex<Option<HashMap<PathBuf, String>>> = Mutex::new(None);
static MTIME_DB: Mutex<Option<Database>> = Mutex::new(None);
static MTIME_ENABLED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(true);
pub(crate) fn set_mtime_check(enabled: bool) {
MTIME_ENABLED.store(enabled, std::sync::atomic::Ordering::Relaxed);
}
fn get_mtime_db() -> Result<std::sync::MutexGuard<'static, Option<Database>>> {
let mut guard = MTIME_DB.lock().unwrap();
if guard.is_none() {
let dir = PathBuf::from(".rsconstruct");
fs::create_dir_all(&dir).context("Failed to create .rsconstruct directory")?;
let db = crate::db::open_or_recreate(&dir.join("mtime.redb"), "Mtime cache")?;
*guard = Some(db);
}
Ok(guard)
}
pub(crate) fn file_checksum(path: &Path) -> Result<String> {
let mut guard = CACHE.lock().unwrap();
let cache = guard.get_or_insert_with(HashMap::new);
if let Some(cached) = cache.get(path) {
return Ok(cached.clone());
}
let contents = fs::read(path)
.with_context(|| format!("Failed to read file for checksum: {}", path.display()))?;
let checksum = hex::encode(Sha256::digest(&contents));
cache.insert(path.to_path_buf(), checksum.clone());
Ok(checksum)
}
fn fast_checksum(path: &Path) -> Result<(String, Option<(String, MtimeEntry)>)> {
let metadata = fs::metadata(path)
.with_context(|| format!("Failed to stat file: {}", path.display()))?;
let mtime = metadata.modified()
.with_context(|| format!("Failed to get mtime: {}", path.display()))?;
let duration = mtime.duration_since(SystemTime::UNIX_EPOCH).unwrap_or_default();
let mtime_secs = i64::try_from(duration.as_secs()).unwrap_or(i64::MAX);
let mtime_nanos = duration.subsec_nanos();
let path_str = path.display().to_string();
let db_guard = get_mtime_db()?;
let cached = if let Some(ref db) = *db_guard {
let read_txn = db.begin_read().context("Failed to begin read transaction for mtime cache")?;
match read_txn.open_table(MTIME_TABLE) {
Ok(table) => {
table.get(path_str.as_str()).ok()
.flatten()
.and_then(|data| serde_json::from_slice::<MtimeEntry>(data.value()).ok())
}
Err(_) => None,
}
} else {
None
};
drop(db_guard);
if let Some(ref entry) = cached {
if entry.mtime_secs == mtime_secs && entry.mtime_nanos == mtime_nanos {
let mut guard = CACHE.lock().unwrap();
let cache = guard.get_or_insert_with(HashMap::new);
cache.insert(path.to_path_buf(), entry.checksum.clone());
return Ok((entry.checksum.clone(), None));
}
}
let checksum = file_checksum(path)?;
let new_entry = MtimeEntry {
mtime_secs,
mtime_nanos,
checksum: checksum.clone(),
};
Ok((checksum, Some((path_str, new_entry))))
}
fn flush_mtime_entries(dirty: Vec<(String, MtimeEntry)>) -> Result<()> {
if dirty.is_empty() {
return Ok(());
}
let db_guard = get_mtime_db()?;
let db = db_guard.as_ref().context("Mtime database not available")?;
let write_txn = db.begin_write().context("Failed to begin write transaction for mtime cache")?;
{
let mut table = write_txn.open_table(MTIME_TABLE)
.context("Failed to open mtime cache table")?;
for (path_str, entry) in &dirty {
let value = serde_json::to_vec(entry)
.context("Failed to serialize mtime entry")?;
table.insert(path_str.as_str(), value.as_slice())
.context("Failed to insert mtime entry")?;
}
}
write_txn.commit().context("Failed to commit mtime cache entries")?;
Ok(())
}
fn hash_checksums(checksums: &[String]) -> String {
let combined = checksums.join(":");
bytes_checksum(combined.as_bytes())
}
pub(crate) fn combined_input_checksum(inputs: &[PathBuf]) -> Result<String> {
let mtime_enabled = MTIME_ENABLED.load(std::sync::atomic::Ordering::Relaxed);
let mut checksums = Vec::with_capacity(inputs.len());
let mut dirty_entries = Vec::new();
for input in inputs {
if input.exists() {
if mtime_enabled {
let (checksum, dirty) = fast_checksum(input)?;
checksums.push(checksum);
if let Some(entry) = dirty {
dirty_entries.push(entry);
}
} else {
checksums.push(file_checksum(input)?);
}
} else {
checksums.push(format!("MISSING:{}", input.display()));
}
}
if mtime_enabled {
flush_mtime_entries(dirty_entries)?;
}
Ok(hash_checksums(&checksums))
}
#[allow(dead_code)]
pub(crate) fn invalidate(path: &Path) {
if let Ok(mut guard) = CACHE.lock() {
if let Some(cache) = guard.as_mut() {
cache.remove(path);
}
}
}
#[allow(dead_code)]
pub(crate) fn clear_cache() {
if let Ok(mut guard) = CACHE.lock() {
*guard = None;
}
}
pub(crate) fn bytes_checksum(data: &[u8]) -> String {
hex::encode(Sha256::digest(data))
}