use anyhow::Result;
use inotify::{Inotify, WatchMask};
use std::collections::HashMap;
use std::os::unix::net::{UnixListener, UnixStream};
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::{Duration, Instant, SystemTime};
use folder_auto_banner::daemon_types::{BannerData, Request, Response};
use folder_auto_banner::fs::{DirEntry, DirSummary};
#[derive(Clone)]
struct CacheEntry {
data: BannerData,
computed_at: Instant,
}
const CACHE_TTL: Duration = Duration::from_secs(300); const SIZE_CACHE_REFRESH_TIMEOUT: Duration = Duration::from_millis(1000);
const SOCKET_NAME: &str = "fabd.sock";
const IDLE_TIMEOUT: Duration = Duration::from_secs(600);
struct Daemon {
cache: Arc<Mutex<HashMap<PathBuf, CacheEntry>>>,
dir_sizes: Arc<Mutex<HashMap<PathBuf, u64>>>,
dir_size_mtimes: Arc<Mutex<HashMap<PathBuf, Option<SystemTime>>>>,
socket_path: PathBuf,
}
impl Daemon {
fn new() -> Result<Self> {
let socket_dir = directories::ProjectDirs::from("com", "fab", "fab")
.ok_or_else(|| anyhow::anyhow!("Cannot determine data directory"))?
.data_dir()
.to_path_buf();
std::fs::create_dir_all(&socket_dir)?;
let socket_path = socket_dir.join(SOCKET_NAME);
if socket_path.exists() {
std::fs::remove_file(&socket_path)?;
}
let dir_sizes = load_size_cache(&socket_dir);
Ok(Self {
cache: Arc::new(Mutex::new(HashMap::new())),
dir_sizes: Arc::new(Mutex::new(dir_sizes)),
dir_size_mtimes: Arc::new(Mutex::new(HashMap::new())),
socket_path,
})
}
fn run(&self) -> Result<()> {
let listener = UnixListener::bind(&self.socket_path)?;
listener.set_nonblocking(true)?;
tracing::info!("fabd listening on {}", self.socket_path.display());
let socket_dir =
directories::ProjectDirs::from("com", "fab", "fab").map(|p| p.data_dir().to_path_buf());
if let Some(ref dir) = socket_dir {
let persisted = load_banner_cache(dir);
let mut cache = self.cache.lock().unwrap_or_else(|e| {
tracing::warn!("Cache mutex poisoned, recovering: {}", e);
e.into_inner()
});
for (path, data) in persisted {
cache.insert(
path,
CacheEntry {
data,
computed_at: Instant::now(),
},
);
}
tracing::info!("Loaded {} banner caches from disk", cache.len());
}
let cache_clone = self.cache.clone();
let _watcher_handle = thread::spawn(move || {
watch_loop(cache_clone);
});
let dir_sizes_clone = self.dir_sizes.clone();
let dir_size_mtimes_clone = self.dir_size_mtimes.clone();
let cache_clone = self.cache.clone();
let socket_dir =
directories::ProjectDirs::from("com", "fab", "fab").map(|p| p.data_dir().to_path_buf());
thread::spawn(move || {
proactive_scan(
dir_sizes_clone.clone(),
dir_size_mtimes_clone,
cache_clone.clone(),
);
if let Some(dir) = socket_dir {
let sizes = dir_sizes_clone.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
save_size_cache(&dir, &sizes);
}
});
let mut last_activity = Instant::now();
let mut last_save = Instant::now();
loop {
match listener.accept() {
Ok((stream, _)) => {
last_activity = Instant::now();
let cache = self.cache.clone();
let dir_sizes = self.dir_sizes.clone();
let dir_size_mtimes = self.dir_size_mtimes.clone();
thread::spawn(move || {
if let Err(e) = handle_client(stream, cache, dir_sizes, dir_size_mtimes) {
tracing::error!("Client error: {}", e);
}
});
}
Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
if last_activity.elapsed() > IDLE_TIMEOUT {
tracing::info!("Idle timeout, shutting down");
break;
}
#[cfg(unix)]
if SHUTDOWN_REQUESTED.load(std::sync::atomic::Ordering::SeqCst) {
tracing::info!("Shutdown signal received, shutting down gracefully");
break;
}
if last_save.elapsed() > Duration::from_secs(300) {
let socket_dir = directories::ProjectDirs::from("com", "fab", "fab")
.map(|p| p.data_dir().to_path_buf());
if let Some(dir) = socket_dir {
let cache = self.cache.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
save_banner_cache(&dir, &cache);
}
last_save = Instant::now();
}
thread::sleep(Duration::from_millis(10));
}
Err(e) => {
tracing::error!("Accept error: {}", e);
thread::sleep(Duration::from_millis(10));
}
}
}
let socket_dir =
directories::ProjectDirs::from("com", "fab", "fab").map(|p| p.data_dir().to_path_buf());
if let Some(dir) = socket_dir {
let cache = self.cache.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
save_banner_cache(&dir, &cache);
}
std::fs::remove_file(&self.socket_path).ok();
Ok(())
}
}
fn watch_loop(cache: Arc<Mutex<HashMap<PathBuf, CacheEntry>>>) {
let mut inotify = match Inotify::init() {
Ok(i) => i,
Err(e) => {
tracing::error!("Failed to init inotify: {}", e);
return;
}
};
let mut watched: HashMap<PathBuf, inotify::WatchDescriptor> = HashMap::new();
let mut failed_watches: std::collections::HashSet<PathBuf> = std::collections::HashSet::new();
loop {
{
let cache = cache.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
for path in cache.keys() {
if !watched.contains_key(path) && !failed_watches.contains(path) {
if !path.exists() {
failed_watches.insert(path.clone());
continue;
}
if let Ok(meta) = std::fs::symlink_metadata(path) {
if meta.is_symlink() && std::fs::metadata(path).is_err() {
failed_watches.insert(path.clone());
continue; }
}
match inotify.watches().add(
path,
WatchMask::CREATE
| WatchMask::DELETE
| WatchMask::MODIFY
| WatchMask::MOVE
| WatchMask::CLOSE_WRITE,
) {
Ok(wd) => {
tracing::info!("Watching: {}", path.display());
watched.insert(path.clone(), wd);
}
Err(e) => {
tracing::warn!("Failed to watch {}: {}", path.display(), e);
failed_watches.insert(path.clone());
}
}
}
}
}
let mut buffer = [0u8; 4096];
match inotify.read_events(&mut buffer) {
Ok(events) => {
for event in events {
let mut invalidated = Vec::new();
for (path, wd) in &watched {
if event.wd == *wd {
invalidated.push(path.clone());
}
}
if !invalidated.is_empty() {
let mut cache_guard = cache.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
for path in &invalidated {
cache_guard.remove(path);
tracing::info!("Cache invalidated: {}", path.display());
}
}
}
}
Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
}
Err(_) => {
}
}
{
let cache = cache.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
let to_remove: Vec<PathBuf> = watched
.keys()
.filter(|p| !cache.contains_key(*p) || !p.exists())
.cloned()
.collect();
for path in to_remove {
if let Some(wd) = watched.remove(&path) {
inotify.watches().remove(wd).ok();
tracing::info!("Stopped watching: {}", path.display());
}
}
failed_watches.retain(|p| cache.contains_key(p));
}
thread::sleep(Duration::from_millis(100));
}
}
fn handle_client(
stream: UnixStream,
cache: Arc<Mutex<HashMap<PathBuf, CacheEntry>>>,
dir_sizes: Arc<Mutex<HashMap<PathBuf, u64>>>,
dir_size_mtimes: Arc<Mutex<HashMap<PathBuf, Option<SystemTime>>>>,
) -> Result<()> {
stream.set_read_timeout(Some(Duration::from_secs(5)))?;
stream.set_write_timeout(Some(Duration::from_secs(5)))?;
let mut stream = stream;
let t_start = std::time::Instant::now();
let mut len_bytes = [0u8; 4];
stream.read_exact(&mut len_bytes)?;
let t_read = std::time::Instant::now();
let req_len = u32::from_le_bytes(len_bytes) as usize;
let mut req_buf = vec![0u8; req_len];
stream.read_exact(&mut req_buf)?;
let request: Request = serde_json::from_slice(&req_buf)?;
let t_parse = std::time::Instant::now();
tracing::debug!(
"Received request: {:?} (read={:?}, parse={:?})",
request,
t_read - t_start,
t_parse - t_read
);
let response = match request {
Request::Banner { path } => {
let path = path.canonicalize().unwrap_or(path);
let cached_entry = {
let cache = cache.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
tracing::debug!("Cache lookup: path={:?}, entries={}", path, cache.len());
cache
.get(&path)
.filter(|entry| entry.computed_at.elapsed() < CACHE_TTL)
.cloned()
};
if let Some(entry) = cached_entry {
let t0 = std::time::Instant::now();
let mut data = entry.data;
let t1 = std::time::Instant::now();
if !cached_summary_is_fresh(&data.summary, &path) {
data = compute_banner_data(&path)?;
let mut cache = cache.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
cache.insert(
path.clone(),
CacheEntry {
data: data.clone(),
computed_at: Instant::now(),
},
);
}
refresh_displayed_dir_sizes(
&mut data.summary.top_items,
&dir_sizes,
&dir_size_mtimes,
);
data.summary.total_size = data.summary.top_items.iter().map(|item| item.size).sum();
let t2 = std::time::Instant::now();
let t3 = std::time::Instant::now();
send_response(&mut stream, &Response::Banner(Box::new(data)))?;
let t4 = std::time::Instant::now();
tracing::debug!(
"Cache hit: clone={:?} refresh={:?} send={:?}",
t1 - t0,
t2 - t1,
t4 - t3
);
let mut discard = [0u8; 256];
loop {
match stream.read(&mut discard) {
Ok(0) => break,
Ok(_) => continue,
Err(_) => break,
}
}
return Ok(());
}
let mut data = compute_banner_data(&path)?;
refresh_displayed_dir_sizes(&mut data.summary.top_items, &dir_sizes, &dir_size_mtimes);
data.summary.total_size = data.summary.top_items.iter().map(|item| item.size).sum();
{
let mut cache = cache.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
cache.insert(
path.clone(),
CacheEntry {
data: data.clone(),
computed_at: Instant::now(),
},
);
}
Response::Banner(Box::new(data))
}
Request::Warm { path } => {
let path = path.canonicalize().unwrap_or(path);
let cache = cache.clone();
thread::spawn(move || {
let cache_hit = {
let c = cache.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
c.get(&path)
.map(|e| e.computed_at.elapsed() < CACHE_TTL)
.unwrap_or(false)
};
if !cache_hit {
if let Ok(data) = compute_banner_data(&path) {
let mut c = cache.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
c.insert(
path,
CacheEntry {
data,
computed_at: Instant::now(),
},
);
}
}
});
return Ok(()); }
Request::DirSize { path } => {
let mut sizes = dir_sizes.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
let mut mtimes = dir_size_mtimes.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
let size = match sizes.get(&path).copied() {
Some(size) if mtimes.get(&path).copied().flatten() == current_dir_mtime(&path) => {
size
}
_ => {
let size = compute_dir_size(&path);
sizes.insert(path.clone(), size);
mtimes.insert(path.clone(), current_dir_mtime(&path));
size
}
};
Response::DirSize { path, size }
}
Request::Ping => Response::Pong,
Request::Shutdown => {
tracing::info!("Shutdown requested");
let socket_dir = directories::ProjectDirs::from("com", "fab", "fab")
.map(|p| p.data_dir().to_path_buf());
if let Some(dir) = socket_dir {
let c = cache.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
save_banner_cache(&dir, &c);
}
std::process::exit(0);
}
};
send_response(&mut stream, &response)?;
tracing::trace!("Sent response successfully");
use std::io::Read;
let mut discard = [0u8; 256];
loop {
match stream.read(&mut discard) {
Ok(0) => break, Ok(_) => continue,
Err(_) => break, }
}
Ok(())
}
fn send_response(stream: &mut UnixStream, response: &Response) -> Result<()> {
use std::io::Write;
let resp_bytes = serde_json::to_vec(response)?;
let resp_len = resp_bytes.len() as u32;
let mut combined = Vec::with_capacity(4 + resp_bytes.len());
let len_bytes = resp_len.to_le_bytes();
combined.extend_from_slice(&len_bytes);
combined.extend_from_slice(&resp_bytes);
stream.write_all(&combined)?;
stream.flush()?;
Ok(())
}
fn compute_banner_data(path: &Path) -> Result<BannerData> {
let summary = DirSummary::scan_with_options(path, false, true, true, true, true)?;
let filter_paths: Vec<String> = summary
.top_items
.iter()
.map(|item| item.name.clone())
.collect();
let mut git_info = folder_auto_banner::git::get_git_info_filtered(path, &filter_paths).ok();
if let Some(ref mut gi) = git_info {
if !gi.file_statuses.is_empty() {
let keep: std::collections::HashSet<_> = summary
.top_items
.iter()
.map(|item| item.name.clone())
.collect();
gi.file_statuses.retain(|path_str, _| {
let components: Vec<_> = std::path::Path::new(path_str)
.components()
.map(|c| c.as_os_str().to_string_lossy().to_string())
.collect();
match components.len() {
0 => false,
1 => keep.contains(&components[0]),
2 => keep.contains(&components[0]), _ => false, }
});
}
}
Ok(BannerData { summary, git_info })
}
fn cached_summary_is_fresh(cached: &DirSummary, path: &Path) -> bool {
let Ok(fresh) = DirSummary::scan_with_options(path, false, false, false, false, false) else {
return false;
};
cached.total_items == fresh.total_items
&& cached.total_size == fresh.total_size
&& cached.files == fresh.files
&& cached.dirs == fresh.dirs
&& cached.project_type == fresh.project_type
&& cached.last_modified == fresh.last_modified
&& cached.top_items.len() == fresh.top_items.len()
&& cached
.top_items
.iter()
.zip(fresh.top_items.iter())
.all(|(a, b)| {
a.name == b.name
&& a.is_dir == b.is_dir
&& a.is_file == b.is_file
&& a.is_symlink == b.is_symlink
&& a.size == b.size
&& a.modified == b.modified
&& a.symlink_valid == b.symlink_valid
})
}
fn refresh_displayed_dir_sizes(
items: &mut [DirEntry],
dir_sizes: &Arc<Mutex<HashMap<PathBuf, u64>>>,
dir_size_mtimes: &Arc<Mutex<HashMap<PathBuf, Option<SystemTime>>>>,
) {
let sizes = dir_sizes.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
let mtimes = dir_size_mtimes.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
let mut to_compute = Vec::new();
for item in items.iter_mut().filter(|item| item.is_dir) {
let current_mtime = current_dir_mtime(&item.path);
let cached_mtime = mtimes.get(&item.path).copied().flatten();
let cached_size = sizes.get(&item.path).copied();
if cached_size.is_none() || cached_mtime != current_mtime {
to_compute.push((item.path.clone(), current_mtime));
} else if let Some(size) = cached_size {
item.size = size;
}
}
drop(mtimes);
drop(sizes);
for (path, mtime) in to_compute {
let size = compute_dir_size(&path);
let mut sizes = dir_sizes.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
sizes.insert(path.clone(), size);
drop(sizes);
let mut mtimes = dir_size_mtimes.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
mtimes.insert(path, mtime);
}
let sizes = dir_sizes.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
for item in items.iter_mut().filter(|item| item.is_dir) {
if let Some(size) = sizes.get(&item.path) {
item.size = *size;
}
}
}
fn current_dir_mtime(path: &Path) -> Option<SystemTime> {
std::fs::metadata(path)
.ok()
.and_then(|metadata| metadata.modified().ok())
}
fn compute_dir_size(path: &Path) -> u64 {
let path_arg = path.to_string_lossy();
if let Ok(stdout) = folder_auto_banner::utils::run_with_timeout_stdout(
"du",
&["-s", "--bytes", path_arg.as_ref()],
SIZE_CACHE_REFRESH_TIMEOUT,
) {
let stdout = stdout.trim();
if !stdout.is_empty() {
let size_str = stdout.split_whitespace().next().unwrap_or("0");
if let Ok(size) = size_str.parse::<u64>() {
return size;
}
}
}
std::fs::metadata(path).map(|m| m.len()).unwrap_or(0)
}
const SIZE_CACHE_FILE: &str = "dir_sizes.json";
const BANNER_CACHE_FILE: &str = "banner_cache.json";
fn size_cache_path(socket_dir: &Path) -> PathBuf {
socket_dir.join(SIZE_CACHE_FILE)
}
fn banner_cache_path(socket_dir: &Path) -> PathBuf {
socket_dir.join(BANNER_CACHE_FILE)
}
fn load_size_cache(socket_dir: &Path) -> HashMap<PathBuf, u64> {
let path = size_cache_path(socket_dir);
if let Ok(data) = std::fs::read_to_string(&path) {
if let Ok(map) = serde_json::from_str::<HashMap<String, u64>>(&data) {
let result: HashMap<PathBuf, u64> = map
.into_iter()
.map(|(k, v)| (PathBuf::from(k), v))
.collect();
tracing::info!("Loaded {} cached directory sizes from disk", result.len());
return result;
}
}
HashMap::new()
}
fn save_size_cache(socket_dir: &Path, sizes: &HashMap<PathBuf, u64>) {
let path = size_cache_path(socket_dir);
let map: HashMap<String, u64> = sizes
.iter()
.map(|(k, v)| (k.to_string_lossy().to_string(), *v))
.collect();
if let Ok(data) = serde_json::to_string(&map) {
if std::fs::write(&path, data).is_ok() {
tracing::info!("Saved {} directory sizes to disk", sizes.len());
}
}
}
fn load_banner_cache(socket_dir: &Path) -> HashMap<PathBuf, BannerData> {
let path = banner_cache_path(socket_dir);
if let Ok(data) = std::fs::read_to_string(&path) {
if let Ok(map) = serde_json::from_str::<HashMap<String, BannerData>>(&data) {
let result: HashMap<PathBuf, BannerData> = map
.into_iter()
.map(|(k, v)| (PathBuf::from(k), v))
.collect();
tracing::info!("Loaded {} cached banners from disk", result.len());
return result;
}
}
HashMap::new()
}
fn save_banner_cache(socket_dir: &Path, cache: &HashMap<PathBuf, CacheEntry>) {
let path = banner_cache_path(socket_dir);
let map: HashMap<String, &BannerData> = cache
.iter()
.map(|(k, v)| (k.to_string_lossy().to_string(), &v.data))
.collect();
if let Ok(data) = serde_json::to_string(&map) {
if std::fs::write(&path, data).is_ok() {
tracing::info!("Saved {} banner caches to disk", cache.len());
}
}
}
fn proactive_scan(
dir_sizes: Arc<Mutex<HashMap<PathBuf, u64>>>,
dir_size_mtimes: Arc<Mutex<HashMap<PathBuf, Option<SystemTime>>>>,
banner_cache: Arc<Mutex<HashMap<PathBuf, CacheEntry>>>,
) {
let home = match std::env::var("HOME") {
Ok(h) => PathBuf::from(h),
Err(_) => return,
};
tracing::info!("Starting proactive scan of {}", home.display());
let mut dirs_to_scan: Vec<PathBuf> = Vec::new();
if let Ok(entries) = std::fs::read_dir(&home) {
for entry in entries.flatten() {
let meta = match std::fs::symlink_metadata(entry.path()) {
Ok(m) => m,
Err(_) => continue,
};
if meta.is_symlink() {
if let Ok(target_meta) = std::fs::metadata(entry.path()) {
if target_meta.is_dir() && !entry.file_name().to_string_lossy().starts_with('.')
{
dirs_to_scan.push(entry.path());
}
}
} else if meta.is_dir() && !entry.file_name().to_string_lossy().starts_with('.') {
dirs_to_scan.push(entry.path());
}
}
}
let level1: Vec<PathBuf> = dirs_to_scan.clone();
for dir in &level1 {
if let Ok(entries) = std::fs::read_dir(dir) {
for entry in entries.flatten().take(50) {
let meta = match std::fs::symlink_metadata(entry.path()) {
Ok(m) => m,
Err(_) => continue,
};
if meta.is_symlink() {
if let Ok(target_meta) = std::fs::metadata(entry.path()) {
if target_meta.is_dir() {
dirs_to_scan.push(entry.path());
}
}
} else if meta.is_dir() {
dirs_to_scan.push(entry.path());
}
}
}
}
let level2_end = dirs_to_scan.len();
let level2: Vec<PathBuf> = dirs_to_scan[level1.len()..].to_vec();
for dir in &level2 {
if let Ok(entries) = std::fs::read_dir(dir) {
for entry in entries.flatten().take(20) {
let meta = match std::fs::symlink_metadata(entry.path()) {
Ok(m) => m,
Err(_) => continue,
};
if meta.is_symlink() {
if let Ok(target_meta) = std::fs::metadata(entry.path()) {
if target_meta.is_dir() {
dirs_to_scan.push(entry.path());
}
}
} else if meta.is_dir() {
dirs_to_scan.push(entry.path());
}
}
}
}
if let Ok(entries) = std::fs::read_dir(&home) {
for entry in entries.flatten() {
let name = entry.file_name().to_string_lossy().to_string();
if name.starts_with('.') {
let meta = match std::fs::symlink_metadata(entry.path()) {
Ok(m) => m,
Err(_) => continue,
};
let is_dir = if meta.is_symlink() {
std::fs::metadata(entry.path())
.map(|m| m.is_dir())
.unwrap_or(false)
} else {
meta.is_dir()
};
if is_dir {
dirs_to_scan.push(entry.path());
}
}
}
}
tracing::info!("Scanning {} directories", dirs_to_scan.len());
let batch_size = 50;
let mut count = 0;
for chunk in dirs_to_scan.chunks(batch_size) {
let mut du_args: Vec<String> = vec!["-s".to_string(), "--bytes".to_string()];
for dir in chunk {
du_args.push(dir.to_string_lossy().to_string());
}
if let Ok(output) = std::process::Command::new("du").args(&du_args).output() {
let mut batch_sizes = Vec::new();
let stdout = String::from_utf8_lossy(&output.stdout);
for line in stdout.lines() {
let parts: Vec<&str> = line.splitn(2, '\t').collect();
if parts.len() >= 2 {
if let Ok(size) = parts[0].parse::<u64>() {
let dir_path = PathBuf::from(parts[1]);
batch_sizes.push((dir_path, size));
count += 1;
}
}
}
let mut sizes = dir_sizes.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
for (path, size) in &batch_sizes {
sizes.insert(path.clone(), *size);
}
drop(sizes);
let mut mtimes = dir_size_mtimes.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
for (path, _) in &batch_sizes {
mtimes.insert(path.clone(), current_dir_mtime(path));
}
drop(mtimes);
}
}
tracing::info!("Proactive scan complete: {} directory sizes cached", count);
let banner_targets: Vec<PathBuf> = dirs_to_scan[..level2_end.min(dirs_to_scan.len())].to_vec();
tracing::info!(
"Pre-computing banners for {} directories",
banner_targets.len()
);
let mut banner_count = 0;
for path in &banner_targets {
let should_compute = {
let cache = banner_cache.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
!cache
.get(path)
.map(|e| e.computed_at.elapsed() < CACHE_TTL)
.unwrap_or(false)
};
if !should_compute {
continue;
}
if let Ok(data) = compute_banner_data(path) {
let mut cache = banner_cache.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
cache.insert(
path.clone(),
CacheEntry {
data,
computed_at: Instant::now(),
},
);
banner_count += 1;
}
}
tracing::info!("Pre-computed {} banner caches", banner_count);
let socket_dir =
directories::ProjectDirs::from("com", "fab", "fab").map(|p| p.data_dir().to_path_buf());
if let Some(dir) = socket_dir {
let cache = banner_cache.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
save_banner_cache(&dir, &cache);
}
}
fn main() -> Result<()> {
tracing_subscriber::fmt()
.with_env_filter(
tracing_subscriber::EnvFilter::try_from_default_env()
.unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info")),
)
.init();
#[cfg(unix)]
{
unsafe {
libc::nice(10);
}
let _ = std::process::Command::new("ionice")
.args(["-c", "3", "-p", &std::process::id().to_string()])
.output();
}
#[cfg(unix)]
{
let handler = signal_wrapper as *const () as libc::sighandler_t;
unsafe {
libc::signal(libc::SIGTERM, handler);
libc::signal(libc::SIGINT, handler);
}
}
tracing::info!("fabd started with resource limits (nice=10, ionice=idle)");
let daemon = Daemon::new()?;
daemon.run()
}
#[cfg(unix)]
static SHUTDOWN_REQUESTED: std::sync::atomic::AtomicBool =
std::sync::atomic::AtomicBool::new(false);
#[cfg(unix)]
extern "C" fn signal_wrapper(_sig: libc::c_int) {
SHUTDOWN_REQUESTED.store(true, std::sync::atomic::Ordering::SeqCst);
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_socket_path() {
let path = directories::ProjectDirs::from("com", "fab", "fab")
.unwrap()
.data_dir()
.join(SOCKET_NAME);
assert!(path.to_string_lossy().contains("fabd.sock"));
}
#[test]
fn test_cache_entry_creation() {
let summary = DirSummary::scan(Path::new("/tmp")).unwrap();
let data = BannerData {
summary,
git_info: None,
};
let entry = CacheEntry {
data,
computed_at: Instant::now(),
};
assert!(entry.computed_at.elapsed() < Duration::from_secs(1));
}
#[test]
fn test_cache_ttl() {
let summary = DirSummary::scan(Path::new("/tmp")).unwrap();
let entry = CacheEntry {
data: BannerData {
summary,
git_info: None,
},
computed_at: Instant::now() - Duration::from_secs(600), };
assert!(entry.computed_at.elapsed() > CACHE_TTL);
}
#[test]
fn test_request_serialization() {
let request = Request::Banner {
path: PathBuf::from("/tmp"),
};
let json = serde_json::to_string(&request).unwrap();
assert!(json.contains("Banner"));
assert!(json.contains("/tmp"));
}
#[test]
fn test_response_serialization() {
let response = Response::Pong;
let json = serde_json::to_string(&response).unwrap();
assert!(json.contains("Pong"));
}
#[test]
fn test_banner_data_serialization() {
let summary = DirSummary::scan(Path::new("/tmp")).unwrap();
let data = BannerData {
summary,
git_info: None,
};
let json = serde_json::to_string(&data).unwrap();
assert!(json.contains("summary"));
}
#[test]
fn test_daemon_new() {
let daemon = Daemon::new();
assert!(daemon.is_ok());
}
#[test]
fn test_compute_dir_size() {
let tmp = tempfile::tempdir().unwrap();
std::fs::write(tmp.path().join("sample.txt"), "hello").unwrap();
let size = compute_dir_size(tmp.path());
assert!(size > 0);
}
#[test]
fn test_cached_summary_is_fresh_detects_new_item() {
let tmp = tempfile::tempdir().unwrap();
std::fs::write(tmp.path().join("a.txt"), "a").unwrap();
let summary =
DirSummary::scan_with_options(tmp.path(), false, false, false, false, false).unwrap();
assert!(cached_summary_is_fresh(&summary, tmp.path()));
std::fs::write(tmp.path().join("b.txt"), "b").unwrap();
assert!(!cached_summary_is_fresh(&summary, tmp.path()));
}
#[test]
fn test_cached_summary_is_fresh_detects_nested_change() {
let tmp = tempfile::tempdir().unwrap();
let child = tmp.path().join("child");
std::fs::create_dir(&child).unwrap();
std::fs::write(child.join("nested.txt"), "before").unwrap();
let summary =
DirSummary::scan_with_options(tmp.path(), false, false, false, false, false).unwrap();
assert!(cached_summary_is_fresh(&summary, tmp.path()));
std::thread::sleep(Duration::from_millis(20));
std::fs::write(child.join("nested-new.txt"), "after").unwrap();
assert!(!cached_summary_is_fresh(&summary, tmp.path()));
}
#[test]
fn test_refresh_displayed_dir_sizes_updates_changed_directory_size() {
let tmp = tempfile::tempdir().unwrap();
let child = tmp.path().join("child");
std::fs::create_dir(&child).unwrap();
std::fs::write(child.join("one.txt"), "one").unwrap();
let mut items = vec![DirEntry {
name: "child".to_string(),
path: child.clone(),
is_dir: true,
is_file: false,
is_symlink: false,
is_exec: true,
size: 0,
modified: None,
perms: String::new(),
owner: String::new(),
group: String::new(),
symlink_target: None,
symlink_valid: true,
}];
let dir_sizes = Arc::new(Mutex::new(HashMap::new()));
let dir_size_mtimes = Arc::new(Mutex::new(HashMap::new()));
refresh_displayed_dir_sizes(&mut items, &dir_sizes, &dir_size_mtimes);
let first_size = items[0].size;
assert!(first_size > 0);
std::thread::sleep(Duration::from_millis(20));
std::fs::write(child.join("two.txt"), "two").unwrap();
refresh_displayed_dir_sizes(&mut items, &dir_sizes, &dir_size_mtimes);
assert!(items[0].size > first_size);
}
}