use anyhow::Result;
use inotify::{Inotify, WatchMask};
use std::collections::{HashMap, HashSet};
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, UNIX_EPOCH};
use folder_auto_banner::daemon_types::{
checked_frame_len, BannerData, Request, Response, MAX_IPC_FRAME_SIZE,
};
#[cfg(test)]
use folder_auto_banner::fs::ProjectType;
use folder_auto_banner::fs::{DirEntry, DirSummary};
#[derive(Clone)]
struct CacheEntry {
data: BannerData,
computed_at: Instant,
root_mtime: Option<SystemTime>,
config_mtime: Option<SystemTime>,
}
const CACHE_TTL: Duration = Duration::from_secs(300); const BACKGROUND_SIZE_CACHE_REFRESH_TIMEOUT: Duration = Duration::from_secs(5);
const ACTIVE_SIZE_REFRESH_TIMEOUT: Duration = Duration::from_secs(10);
const ACTIVE_SIZE_REFRESH_INTERVAL: Duration = Duration::from_secs(30);
const ACTIVE_SIZE_REFRESH_ROOTS_PER_TICK: usize = 5;
const MAX_SIZE_COMPUTE_THREADS: usize = 16;
const SOCKET_NAME: &str = "fabd.sock";
const IDLE_TIMEOUT: Duration = Duration::from_secs(600); const WATCH_REFRESH_INTERVAL: Duration = Duration::from_secs(1);
const ACTIVE_WATCH_DEPTH: usize = 3;
const MAX_ACTIVE_WATCH_DIRS: usize = 2048;
const MAX_WATCH_CHILDREN_PER_DIR: usize = 500;
#[cfg(test)]
#[derive(Clone, Debug, PartialEq)]
struct ShallowSnapshot {
total_items: usize,
total_size: u64,
files: usize,
dirs: usize,
project_type: ProjectType,
last_modified: Option<SystemTime>,
top_items: Vec<ShallowItem>,
}
#[cfg(test)]
#[derive(Clone, Debug, PartialEq)]
struct ShallowItem {
name: String,
is_dir: bool,
is_file: bool,
is_symlink: bool,
size: u64,
modified: Option<SystemTime>,
symlink_valid: bool,
}
#[derive(Clone, Debug)]
struct WatchRegistration {
owner: PathBuf,
watched_path: PathBuf,
}
#[derive(Clone, Copy)]
struct SizeComputation {
size: u64,
measured: bool,
}
type SizeComputeResult = (usize, u64, Option<SystemTime>, bool);
struct SizeRefreshGuard {
in_flight: Arc<Mutex<HashSet<PathBuf>>>,
path: PathBuf,
}
impl Drop for SizeRefreshGuard {
fn drop(&mut self) {
let mut in_flight = self.in_flight.lock().unwrap_or_else(|e| {
tracing::warn!("In-flight size-refresh mutex poisoned, recovering");
e.into_inner()
});
in_flight.remove(&self.path);
}
}
#[derive(Clone)]
struct SizeRefreshContext {
cache: Arc<Mutex<HashMap<PathBuf, CacheEntry>>>,
dir_sizes: Arc<Mutex<HashMap<PathBuf, u64>>>,
dir_size_mtimes: Arc<Mutex<HashMap<PathBuf, Option<SystemTime>>>>,
pending_size_refreshes: Arc<Mutex<Vec<PathBuf>>>,
size_refresh_in_flight: Arc<Mutex<HashSet<PathBuf>>>,
active_roots: Arc<Mutex<HashSet<PathBuf>>>,
active_order: Arc<Mutex<Vec<PathBuf>>>,
}
struct Daemon {
cache: Arc<Mutex<HashMap<PathBuf, CacheEntry>>>,
dir_sizes: Arc<Mutex<HashMap<PathBuf, u64>>>,
dir_size_mtimes: Arc<Mutex<HashMap<PathBuf, Option<SystemTime>>>>,
pending_size_refreshes: Arc<Mutex<Vec<PathBuf>>>,
size_refresh_in_flight: Arc<Mutex<HashSet<PathBuf>>>,
socket_path: PathBuf,
}
impl Daemon {
fn new() -> Result<Self> {
let socket_dir = folder_auto_banner::state::get_data_dir()?;
let socket_path = socket_dir.join(SOCKET_NAME);
if socket_path.exists() {
if std::os::unix::net::UnixStream::connect(&socket_path).is_ok() {
anyhow::bail!(
"daemon already running (socket {} is live)",
socket_path.display()
);
}
std::fs::remove_file(&socket_path)?;
}
let (dir_sizes, dir_size_mtimes) = 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(dir_size_mtimes)),
pending_size_refreshes: Arc::new(Mutex::new(Vec::new())),
size_refresh_in_flight: Arc::new(Mutex::new(HashSet::new())),
socket_path,
})
}
fn run(&self) -> Result<()> {
let listener = UnixListener::bind(&self.socket_path)?;
listener.set_nonblocking(true)?;
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let _ =
std::fs::set_permissions(&self.socket_path, std::fs::Permissions::from_mode(0o600));
}
tracing::info!("fabd listening on {}", self.socket_path.display());
let cache_clone = self.cache.clone();
let dir_sizes_clone = self.dir_sizes.clone();
let dir_size_mtimes_clone = self.dir_size_mtimes.clone();
let active_roots = Arc::new(Mutex::new(HashSet::new()));
let active_order = Arc::new(Mutex::new(Vec::new()));
let active_roots_clone = active_roots.clone();
let active_order_clone = active_order.clone();
let _watcher_handle = thread::spawn(move || {
watch_loop(
cache_clone,
dir_sizes_clone,
dir_size_mtimes_clone,
active_roots_clone,
active_order_clone,
);
});
let socket_dir = folder_auto_banner::state::get_data_dir().ok();
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 {
active_roots
.lock()
.unwrap_or_else(|e| {
tracing::warn!("Active roots mutex poisoned, recovering");
e.into_inner()
})
.insert(path.clone());
active_order
.lock()
.unwrap_or_else(|e| {
tracing::warn!("Active order mutex poisoned, recovering");
e.into_inner()
})
.insert(0, path.clone());
cache.insert(
path.clone(),
CacheEntry {
data,
computed_at: Instant::now() - CACHE_TTL,
root_mtime: current_dir_mtime(&path),
config_mtime: current_config_mtime(),
},
);
}
tracing::info!("Loaded {} banner caches from disk", cache.len());
}
let size_refresh_ctx = Arc::new(SizeRefreshContext {
cache: self.cache.clone(),
dir_sizes: self.dir_sizes.clone(),
dir_size_mtimes: self.dir_size_mtimes.clone(),
pending_size_refreshes: self.pending_size_refreshes.clone(),
size_refresh_in_flight: self.size_refresh_in_flight.clone(),
active_roots: active_roots.clone(),
active_order: active_order.clone(),
});
let active_size_refresh_ctx = size_refresh_ctx.clone();
thread::spawn(move || active_size_refresh_loop(active_size_refresh_ctx));
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();
let active_roots = active_roots.clone();
let active_order = active_order.clone();
let size_refresh_ctx = size_refresh_ctx.clone();
thread::spawn(move || {
if let Err(e) = handle_client(
stream,
cache,
dir_sizes,
dir_size_mtimes,
active_roots,
active_order,
size_refresh_ctx,
) {
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()
});
let dir_sizes = self.dir_sizes.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
let dir_size_mtimes = self.dir_size_mtimes.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
save_banner_cache(&dir, &cache);
save_size_cache(&dir, &dir_sizes, &dir_size_mtimes);
}
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()
});
let dir_sizes = self.dir_sizes.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
let dir_size_mtimes = self.dir_size_mtimes.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
save_banner_cache(&dir, &cache);
save_size_cache(&dir, &dir_sizes, &dir_size_mtimes);
}
std::fs::remove_file(&self.socket_path).ok();
Ok(())
}
}
fn watch_loop(
cache: Arc<Mutex<HashMap<PathBuf, CacheEntry>>>,
dir_sizes: Arc<Mutex<HashMap<PathBuf, u64>>>,
dir_size_mtimes: Arc<Mutex<HashMap<PathBuf, Option<SystemTime>>>>,
active_roots: Arc<Mutex<HashSet<PathBuf>>>,
active_order: Arc<Mutex<Vec<PathBuf>>>,
) {
let mut inotify = match Inotify::init() {
Ok(i) => i,
Err(e) => {
tracing::error!("Failed to init inotify: {}", e);
return;
}
};
let mut watched: HashMap<inotify::WatchDescriptor, Vec<WatchRegistration>> = HashMap::new();
let mut failed_watches: HashSet<PathBuf> = HashSet::new();
let mut last_refresh = Instant::now() - WATCH_REFRESH_INTERVAL;
let mut last_cleanup = Instant::now() - WATCH_REFRESH_INTERVAL;
let mut last_roots: HashSet<PathBuf> = HashSet::new();
let mut last_order: Vec<PathBuf> = Vec::new();
loop {
let now = Instant::now();
let mut roots_snapshot = if last_refresh.elapsed() >= WATCH_REFRESH_INTERVAL {
Some(
active_roots
.lock()
.unwrap_or_else(|e| {
tracing::warn!("Active roots mutex poisoned, recovering");
e.into_inner()
})
.clone(),
)
} else {
None
};
let mut order_snapshot = if last_refresh.elapsed() >= WATCH_REFRESH_INTERVAL {
Some(
active_order
.lock()
.unwrap_or_else(|e| {
tracing::warn!("Active order mutex poisoned, recovering");
e.into_inner()
})
.clone(),
)
} else {
None
};
if last_refresh.elapsed() >= WATCH_REFRESH_INTERVAL {
let roots = roots_snapshot.take().unwrap_or_else(|| {
active_roots
.lock()
.unwrap_or_else(|e| {
tracing::warn!("Active roots mutex poisoned, recovering");
e.into_inner()
})
.clone()
});
let order = order_snapshot.take().unwrap_or_else(|| {
active_order
.lock()
.unwrap_or_else(|e| {
tracing::warn!("Active order mutex poisoned, recovering");
e.into_inner()
})
.clone()
});
if roots != last_roots || order != last_order {
refresh_active_watchers(
&mut inotify,
&roots,
&order,
&mut watched,
&mut failed_watches,
);
last_roots = roots;
last_order = order;
}
last_refresh = now;
}
if last_cleanup.elapsed() >= WATCH_REFRESH_INTERVAL {
let roots = if let Some(roots) = roots_snapshot.take() {
roots
} else {
active_roots
.lock()
.unwrap_or_else(|e| {
tracing::warn!("Active roots mutex poisoned, recovering");
e.into_inner()
})
.clone()
};
active_order
.lock()
.unwrap_or_else(|e| {
tracing::warn!("Active order mutex poisoned, recovering");
e.into_inner()
})
.retain(|path| roots.contains(path));
remove_inactive_watchers(
&roots,
&active_order,
&mut inotify,
&mut watched,
&mut failed_watches,
);
last_cleanup = now;
}
let mut buffer = [0u8; 8192];
match inotify.read_events(&mut buffer) {
Ok(events) => {
for event in events {
let mut invalidated = Vec::new();
if let Some(registrations) = watched.get(&event.wd) {
for reg in registrations {
invalidated.push(reg.owner.clone());
}
}
if !invalidated.is_empty() {
let is_root_event = watched
.get(&event.wd)
.and_then(|regs| regs.first())
.map(|r| r.watched_path == r.owner)
.unwrap_or(false);
let is_file_modify = event.mask.contains(inotify::EventMask::MODIFY)
|| event.mask.contains(inotify::EventMask::CLOSE_WRITE);
let has_content_probe_ext = if is_file_modify
&& !event.mask.contains(inotify::EventMask::ISDIR)
{
event
.name
.map(|n| {
folder_auto_banner::cmd::banner_data_cache::
is_content_probe_ext(&n.to_string_lossy().to_ascii_lowercase())
})
.unwrap_or(false)
} else {
false
};
let invalidate_banner = is_root_event || has_content_probe_ext;
if invalidate_banner {
let mut cache_guard = cache.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
const MIN_INVALIDATION_AGE: Duration = Duration::from_secs(10);
for path in &invalidated {
if let Some(entry) = cache_guard.get(path) {
if entry.computed_at.elapsed() < MIN_INVALIDATION_AGE {
continue;
}
}
if cache_guard.remove(path).is_some() {
prune_size_cache_for_root(&dir_sizes, &dir_size_mtimes, path);
folder_auto_banner::cmd::banner_data_cache::remove_cache(path);
tracing::info!("Cache invalidated: {}", path.display());
}
}
} else {
for path in &invalidated {
prune_size_cache_for_root(&dir_sizes, &dir_size_mtimes, path);
tracing::debug!(
"Size cache pruned for descendant event under: {}",
path.display()
);
}
}
}
}
}
Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
}
Err(_) => {
}
}
thread::sleep(Duration::from_millis(100));
}
}
fn refresh_active_watchers(
inotify: &mut Inotify,
roots: &HashSet<PathBuf>,
active_order: &[PathBuf],
watched: &mut HashMap<inotify::WatchDescriptor, Vec<WatchRegistration>>,
failed_watches: &mut HashSet<PathBuf>,
) {
let mut targets = Vec::new();
for root in active_order {
if targets.len() >= MAX_ACTIVE_WATCH_DIRS {
tracing::warn!(
"Reached active watcher cap ({} entries); skipping remaining active folders",
MAX_ACTIVE_WATCH_DIRS
);
break;
}
collect_watch_targets(root, 0, &mut targets, MAX_ACTIVE_WATCH_DIRS);
}
for target in targets {
if watched
.values()
.any(|regs| regs.iter().any(|reg| reg.watched_path == target))
{
continue;
}
if !can_watch_path(&target) {
failed_watches.insert(target);
continue;
}
match inotify.watches().add(
&target,
WatchMask::CREATE
| WatchMask::DELETE
| WatchMask::MODIFY
| WatchMask::MOVE
| WatchMask::CLOSE_WRITE
| WatchMask::ATTRIB
| WatchMask::DELETE_SELF
| WatchMask::MOVE_SELF,
) {
Ok(wd) => {
failed_watches.remove(&target);
let owner = find_owner_for_watch(&target, roots);
let regs = watched.entry(wd).or_default();
if !regs.iter().any(|reg| reg.owner == owner) {
regs.push(WatchRegistration {
owner,
watched_path: target.clone(),
});
tracing::debug!("Watching active path: {}", target.display());
}
}
Err(e) => {
tracing::debug!("Failed to watch {}: {}", target.display(), e);
failed_watches.insert(target);
}
}
}
}
fn collect_watch_targets(
path: &Path,
depth: usize,
targets: &mut Vec<PathBuf>,
max_targets: usize,
) {
if targets.len() >= max_targets || depth > ACTIVE_WATCH_DEPTH {
return;
}
let meta = match std::fs::symlink_metadata(path) {
Ok(meta) => meta,
Err(_) => return,
};
if meta.is_symlink() {
return;
}
let is_dir = meta.is_dir();
if is_dir && should_skip_dir(path) {
return;
}
targets.push(path.to_path_buf());
if !is_dir {
return;
}
let Ok(entries) = std::fs::read_dir(path) else {
return;
};
for entry in entries.take(MAX_WATCH_CHILDREN_PER_DIR).flatten() {
if targets.len() >= max_targets {
return;
}
collect_watch_targets(&entry.path(), depth + 1, targets, max_targets);
}
}
fn should_skip_dir(path: &Path) -> bool {
let Some(name) = path.file_name().and_then(|n| n.to_str()) else {
return false;
};
folder_auto_banner::utils::SKIP_DIRS.contains(&name)
}
fn can_watch_path(path: &Path) -> bool {
let meta = match std::fs::symlink_metadata(path) {
Ok(meta) => meta,
Err(_) => return false,
};
!meta.is_symlink() && (meta.is_file() || meta.is_dir())
}
fn find_owner_for_watch(path: &Path, active_roots: &HashSet<PathBuf>) -> PathBuf {
let roots = active_roots;
roots
.iter()
.filter(|root| path == root.as_path() || path.starts_with(root.as_path()))
.max_by_key(|root| root.components().count())
.cloned()
.unwrap_or_else(|| path.to_path_buf())
}
fn remove_inactive_watchers(
roots: &HashSet<PathBuf>,
active_order: &Arc<Mutex<Vec<PathBuf>>>,
inotify: &mut Inotify,
watched: &mut HashMap<inotify::WatchDescriptor, Vec<WatchRegistration>>,
failed_watches: &mut HashSet<PathBuf>,
) {
active_order
.lock()
.unwrap_or_else(|e| {
tracing::warn!("Active order mutex poisoned, recovering");
e.into_inner()
})
.retain(|path| roots.contains(path));
let to_remove: Vec<_> = watched
.iter_mut()
.filter_map(|(wd, regs)| {
regs.retain(|reg| {
roots.contains(®.owner)
&& reg.owner.exists()
&& (reg.watched_path.exists() || reg.watched_path == reg.owner)
});
if regs.is_empty() {
Some(wd.clone())
} else {
None
}
})
.collect();
for wd in to_remove {
if let Some(regs) = watched.remove(&wd) {
if let Some(reg) = regs.first() {
inotify.watches().remove(wd).ok();
tracing::debug!("Stopped watching: {}", reg.watched_path.display());
}
}
}
failed_watches.retain(|path| is_path_under_any_root(path, roots));
}
fn is_path_under_any_root(path: &Path, roots: &HashSet<PathBuf>) -> bool {
roots
.iter()
.any(|root| path == root || path.starts_with(root))
}
fn touch_active_root(
active_roots: &Arc<Mutex<HashSet<PathBuf>>>,
active_order: &Arc<Mutex<Vec<PathBuf>>>,
path: PathBuf,
) {
active_roots
.lock()
.unwrap_or_else(|e| {
tracing::warn!("Active roots mutex poisoned, recovering");
e.into_inner()
})
.insert(path.clone());
let mut order = active_order.lock().unwrap_or_else(|e| {
tracing::warn!("Active order mutex poisoned, recovering");
e.into_inner()
});
if let Some(pos) = order.iter().position(|p| p == &path) {
order.remove(pos);
}
order.insert(0, path);
}
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>>>>,
active_roots: Arc<Mutex<HashSet<PathBuf>>>,
active_order: Arc<Mutex<Vec<PathBuf>>>,
size_refresh_ctx: Arc<SizeRefreshContext>,
) -> Result<()> {
stream.set_read_timeout(Some(Duration::from_secs(5)))?;
stream.set_write_timeout(Some(Duration::from_secs(5)))?;
let mut stream = stream;
use std::io::Read;
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;
if req_len > MAX_IPC_FRAME_SIZE {
send_response(
&mut stream,
&Response::Error {
message: "IPC request exceeds the maximum frame size".to_string(),
},
)?;
return Ok(());
}
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_else(|_| path.clone());
touch_active_root(&active_roots, &active_order, path.clone());
let _t_req_start = std::time::Instant::now();
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| cache_entry_is_fresh(entry, &path))
.cloned()
};
if let Some(entry) = cached_entry {
let t0 = std::time::Instant::now();
let root_fresh = cache_entry_root_is_fresh(&entry, &path);
let mut data = entry.data;
let t1 = std::time::Instant::now();
let _t_root_done = t1;
if !root_fresh {
tracing::debug!(
"Cache recompute: path={} root_fresh={} root_mtime={:?} current_mtime={:?}",
path.display(),
root_fresh,
entry.root_mtime,
current_dir_mtime(&path),
);
data = match compute_banner_data(&path) {
Ok(data) => data,
Err(e) => {
send_response(
&mut stream,
&Response::Error {
message: e.to_string(),
},
)?;
return Ok(());
}
};
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(),
root_mtime: current_dir_mtime(&path),
config_mtime: current_config_mtime(),
},
);
touch_active_root(&active_roots, &active_order, path.clone());
}
if apply_cached_displayed_dir_sizes(
&mut data.summary.top_items,
&dir_sizes,
&dir_size_mtimes,
) {
enqueue_size_refresh(&size_refresh_ctx, path.clone());
schedule_size_refresh(
size_refresh_ctx.clone(),
path.clone(),
data.clone(),
BACKGROUND_SIZE_CACHE_REFRESH_TIMEOUT,
);
}
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();
persist_banner_data_cache(&path, &data);
send_response(&mut stream, &Response::Banner(Box::new(data)))?;
let t4 = std::time::Instant::now();
tracing::debug!(
"Cache hit: clone={:?} root_check={:?} send={:?} total={:?}",
t1 - t0,
t2 - t1,
t4 - t3,
t4 - _t_req_start,
);
return Ok(());
}
let mut data = match compute_banner_data(&path) {
Ok(data) => data,
Err(e) => {
send_response(
&mut stream,
&Response::Error {
message: e.to_string(),
},
)?;
return Ok(());
}
};
apply_cached_displayed_dir_sizes(
&mut data.summary.top_items,
&dir_sizes,
&dir_size_mtimes,
);
{
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(),
root_mtime: current_dir_mtime(&path),
config_mtime: current_config_mtime(),
},
);
touch_active_root(&active_roots, &active_order, path.clone());
}
persist_banner_data_cache(&path, &data);
schedule_size_refresh(
size_refresh_ctx,
path.clone(),
data.clone(),
BACKGROUND_SIZE_CACHE_REFRESH_TIMEOUT,
);
Response::Banner(Box::new(data))
}
Request::Warm { path } => {
let path = path.canonicalize().unwrap_or_else(|_| path.clone());
let cache = cache.clone();
let active_order = active_order.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| cache_entry_is_fresh(e, &path))
.unwrap_or(false)
};
if !cache_hit {
match compute_banner_data(&path) {
Ok(mut data) => {
apply_cached_displayed_dir_sizes(
&mut data.summary.top_items,
&dir_sizes,
&dir_size_mtimes,
);
let mut c = cache.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
c.insert(
path.clone(),
CacheEntry {
data: data.clone(),
computed_at: Instant::now(),
root_mtime: current_dir_mtime(&path),
config_mtime: current_config_mtime(),
},
);
touch_active_root(&active_roots, &active_order, path.clone());
drop(c);
schedule_size_refresh(
size_refresh_ctx,
path,
data,
BACKGROUND_SIZE_CACHE_REFRESH_TIMEOUT,
);
}
Err(e) => {
tracing::debug!("Warm request failed for {}: {}", path.display(), e);
}
}
}
});
return Ok(()); }
Request::Ping => Response::Pong,
Request::Shutdown => {
tracing::info!("Shutdown requested");
#[cfg(unix)]
SHUTDOWN_REQUESTED.store(true, std::sync::atomic::Ordering::SeqCst);
Response::Pong
}
};
send_response(&mut stream, &response)?;
tracing::trace!("Sent response successfully");
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 = checked_frame_len(resp_bytes.len())
.ok_or_else(|| anyhow::anyhow!("IPC response exceeds the maximum frame size"))?;
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 persist_banner_data_cache(path: &Path, data: &BannerData) {
use folder_auto_banner::cmd::banner_data_cache;
let _ = banner_data_cache::write_cache(path, data);
}
fn compute_banner_data(path: &Path) -> Result<BannerData> {
let config = folder_auto_banner::state::Config::load().unwrap_or_default();
let extra_skip_dirs: Vec<&str> = config.ignore_dirs.iter().map(String::as_str).collect();
let mut summary = DirSummary::scan_with_options(
path,
config.build_status,
folder_auto_banner::utils::feature_enabled(config.todo_count, "FAB_TODOS", "FAB_NO_TODOS"),
folder_auto_banner::utils::feature_enabled(config.ports, "FAB_PORTS", "FAB_NO_PORTS"),
folder_auto_banner::utils::feature_enabled(config.docker, "FAB_DOCKER", "FAB_NO_DOCKER"),
folder_auto_banner::utils::feature_enabled(
config.languages,
"FAB_METRICS",
"FAB_NO_METRICS",
),
&extra_skip_dirs,
)?;
let filter_paths = folder_auto_banner::git::status_filter_paths_for_items(&summary.top_items);
let cache = folder_auto_banner::cache::Cache::new().ok();
let mut git_info: Option<folder_auto_banner::git::GitInfo> = None;
if config.git_status {
if let Some(ref cache) = cache {
let ck = folder_auto_banner::cache::cache_key(path, "git");
if let Some(cached) = cache.get(&ck, std::time::Duration::from_secs(60)) {
git_info = Some(cached);
}
}
}
if config.git_status && git_info.is_none() {
git_info = folder_auto_banner::git::get_git_info_filtered(path, &filter_paths).ok();
if let (Some(ref mut gi), Some(ref cache)) = (&mut git_info, &cache) {
let keep: HashSet<_> = summary
.top_items
.iter()
.map(|item| item.name.clone())
.collect();
gi.file_statuses.retain(|path_str, _| {
folder_auto_banner::git::is_displayed_git_status_path(path_str, &keep)
});
let ck = folder_auto_banner::cache::cache_key(path, "git");
let _ = cache.set(&ck, gi.clone());
}
}
if let Some(ref mut gi) = git_info {
if !gi.file_statuses.is_empty() {
let keep: HashSet<_> = summary
.top_items
.iter()
.map(|item| item.name.clone())
.collect();
gi.file_statuses.retain(|path_str, _| {
folder_auto_banner::git::is_displayed_git_status_path(path_str, &keep)
});
}
}
populate_content_probes(&mut summary.top_items);
Ok(BannerData { summary, git_info })
}
fn populate_content_probes(items: &mut [DirEntry]) {
use folder_auto_banner::cmd::file_metadata::get_file_contents;
for entry in items.iter_mut() {
if !entry.is_file {
continue;
}
let probe = get_file_contents(entry);
entry.content_probe = if probe.is_empty() {
Some(String::new())
} else {
Some(probe)
};
}
}
fn cache_entry_root_is_fresh(entry: &CacheEntry, path: &Path) -> bool {
entry.root_mtime == current_dir_mtime(path)
}
#[cfg(test)]
fn shallow_snapshot(path: &Path) -> Result<ShallowSnapshot> {
let mut top_items = Vec::new();
let mut total_size = 0;
let mut files = 0;
let mut dirs = 0;
let mut last_modified: Option<SystemTime> = None;
for entry in std::fs::read_dir(path)? {
let entry = entry?;
let symlink_meta = std::fs::symlink_metadata(entry.path()).ok();
let Some(metadata) = symlink_meta else {
continue;
};
let is_symlink = metadata.file_type().is_symlink();
let is_dir = if is_symlink {
std::fs::metadata(entry.path())
.map(|m| m.is_dir())
.unwrap_or(false)
} else {
metadata.is_dir()
};
let is_file = !is_symlink && metadata.is_file();
if is_dir {
dirs += 1;
} else if is_file {
files += 1;
}
let size = metadata.len();
total_size += size;
let modified = metadata.modified().ok();
if let Some(mod_time) = modified {
if last_modified.is_none() || mod_time > last_modified.unwrap() {
last_modified = Some(mod_time);
}
}
top_items.push(ShallowItem {
name: entry.file_name().to_string_lossy().to_string(),
is_dir,
is_file,
is_symlink,
size,
modified,
symlink_valid: !is_symlink || std::fs::metadata(entry.path()).is_ok(),
});
}
top_items.sort_by(|a, b| a.name.cmp(&b.name));
Ok(ShallowSnapshot {
total_items: top_items.len(),
total_size,
files,
dirs,
project_type: ProjectType::detect(path),
last_modified,
top_items,
})
}
fn prune_size_cache_for_root(
dir_sizes: &Arc<Mutex<HashMap<PathBuf, u64>>>,
dir_size_mtimes: &Arc<Mutex<HashMap<PathBuf, Option<SystemTime>>>>,
root: &Path,
) {
dir_sizes
.lock()
.unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
})
.retain(|path, _| path != root && !path.starts_with(root));
dir_size_mtimes
.lock()
.unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
})
.retain(|path, _| path != root && !path.starts_with(root));
}
fn apply_cached_displayed_dir_sizes(
items: &mut [DirEntry],
dir_sizes: &Arc<Mutex<HashMap<PathBuf, u64>>>,
dir_size_mtimes: &Arc<Mutex<HashMap<PathBuf, Option<SystemTime>>>>,
) -> bool {
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 needs_refresh = false;
for item in items.iter_mut().filter(|item| item.is_dir) {
if should_skip_dir(&item.path) {
continue;
}
let cached_mtime = mtimes.get(&item.path).copied().flatten();
match sizes.get(&item.path).copied() {
Some(size) if cached_dir_size_is_fresh(&item.path, size, cached_mtime) => {
item.size = size;
}
_ => needs_refresh = true,
}
}
needs_refresh
}
fn active_size_refresh_loop(ctx: Arc<SizeRefreshContext>) {
loop {
thread::sleep(ACTIVE_SIZE_REFRESH_INTERVAL);
let roots: Vec<PathBuf> = {
let mut pending = ctx.pending_size_refreshes.lock().unwrap_or_else(|e| {
tracing::warn!("Pending size-refresh mutex poisoned, recovering");
e.into_inner()
});
let mut out = Vec::with_capacity(ACTIVE_SIZE_REFRESH_ROOTS_PER_TICK);
let mut remaining = Vec::new();
for path in pending.drain(..) {
if out.len() < ACTIVE_SIZE_REFRESH_ROOTS_PER_TICK && !out.contains(&path) {
out.push(path);
} else if !remaining.contains(&path) {
remaining.push(path);
}
}
*pending = remaining;
drop(pending);
if out.is_empty() {
let order = ctx.active_order.lock().unwrap_or_else(|e| {
tracing::warn!("Active order mutex poisoned, recovering");
e.into_inner()
});
order
.iter()
.take(ACTIVE_SIZE_REFRESH_ROOTS_PER_TICK)
.cloned()
.collect()
} else {
out
}
};
for path in roots {
let data = {
let cache = ctx.cache.lock().unwrap_or_else(|e| {
tracing::warn!("Cache mutex poisoned, recovering");
e.into_inner()
});
cache
.get(&path)
.filter(|entry| cache_entry_is_fresh(entry, &path))
.map(|entry| entry.data.clone())
};
if let Some(mut data) = data {
if apply_cached_displayed_dir_sizes(
&mut data.summary.top_items,
&ctx.dir_sizes,
&ctx.dir_size_mtimes,
) {
schedule_size_refresh(ctx.clone(), path, data, ACTIVE_SIZE_REFRESH_TIMEOUT);
}
}
}
}
}
fn enqueue_size_refresh(ctx: &Arc<SizeRefreshContext>, path: PathBuf) {
let mut pending = ctx.pending_size_refreshes.lock().unwrap_or_else(|e| {
tracing::warn!("Pending size-refresh mutex poisoned, recovering");
e.into_inner()
});
if !pending.contains(&path) {
pending.push(path);
}
}
fn mark_size_refresh_in_flight(ctx: &Arc<SizeRefreshContext>, path: &Path) -> bool {
let mut in_flight = ctx.size_refresh_in_flight.lock().unwrap_or_else(|e| {
tracing::warn!("In-flight size-refresh mutex poisoned, recovering");
e.into_inner()
});
in_flight.insert(path.to_path_buf())
}
fn schedule_size_refresh(
ctx: Arc<SizeRefreshContext>,
path: PathBuf,
data: BannerData,
timeout: Duration,
) {
if !mark_size_refresh_in_flight(&ctx, &path) {
return;
}
let computed_at = Instant::now();
thread::spawn(move || {
let _guard = SizeRefreshGuard {
in_flight: ctx.size_refresh_in_flight.clone(),
path: path.clone(),
};
let mut refreshed = data;
refresh_displayed_dir_sizes(
&mut refreshed.summary.top_items,
&ctx.dir_sizes,
&ctx.dir_size_mtimes,
timeout,
);
refreshed.summary.total_size = refreshed
.summary
.top_items
.iter()
.map(|item| item.size)
.sum();
let mut c = ctx.cache.lock().unwrap_or_else(|e| {
tracing::warn!("Mutex poisoned, recovering");
e.into_inner()
});
let should_replace = c
.get(&path)
.map(|entry| entry.computed_at <= computed_at)
.unwrap_or(true);
if should_replace {
c.insert(
path.clone(),
CacheEntry {
data: refreshed,
computed_at,
root_mtime: current_dir_mtime(&path),
config_mtime: current_config_mtime(),
},
);
if let Some(entry) = c.get(&path) {
let _ = folder_auto_banner::cmd::banner_data_cache::write_cache(&path, &entry.data);
}
touch_active_root(&ctx.active_roots, &ctx.active_order, path);
}
});
}
fn refresh_displayed_dir_sizes(
items: &mut [DirEntry],
dir_sizes: &Arc<Mutex<HashMap<PathBuf, u64>>>,
dir_size_mtimes: &Arc<Mutex<HashMap<PathBuf, Option<SystemTime>>>>,
timeout: Duration,
) {
let mut jobs: Vec<(usize, PathBuf, Option<SystemTime>)> = Vec::new();
{
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()
});
for (idx, item) in items.iter_mut().enumerate() {
if !item.is_dir {
continue;
}
if should_skip_dir(&item.path) {
continue;
}
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 let Some(size) = cached_size {
if cached_dir_size_is_fresh(&item.path, size, cached_mtime) {
item.size = size;
continue;
}
}
jobs.push((idx, item.path.clone(), current_mtime));
}
}
if jobs.is_empty() {
return;
}
let results = compute_sizes_parallel(jobs, timeout);
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()
});
for (idx, size, mtime_opt, measured) in results {
let path = items[idx].path.clone();
sizes.insert(path.clone(), size);
if measured {
if let Some(mt) = mtime_opt {
mtimes.insert(path, Some(mt));
}
} else {
mtimes.insert(path, None);
}
items[idx].size = size;
}
drop(sizes);
drop(mtimes);
}
fn compute_sizes_parallel(
jobs: Vec<(usize, PathBuf, Option<SystemTime>)>,
timeout: Duration,
) -> Vec<SizeComputeResult> {
use std::sync::atomic::{AtomicUsize, Ordering};
if jobs.is_empty() {
return Vec::new();
}
let worker_count = jobs.len().min(MAX_SIZE_COMPUTE_THREADS);
let results: std::sync::Mutex<Vec<SizeComputeResult>> =
std::sync::Mutex::new(Vec::with_capacity(jobs.len()));
let next = AtomicUsize::new(0);
std::thread::scope(|s| {
for _ in 0..worker_count {
s.spawn(|| loop {
let idx = next.fetch_add(1, Ordering::SeqCst);
if idx >= jobs.len() {
break;
}
let (orig_idx, path, mtime) = &jobs[idx];
let computed = compute_dir_size_with_status(path, timeout);
if let Ok(mut r) = results.lock() {
r.push((*orig_idx, computed.size, *mtime, computed.measured));
}
});
}
});
results.into_inner().unwrap_or_default()
}
fn current_dir_mtime(path: &Path) -> Option<SystemTime> {
std::fs::metadata(path)
.ok()
.and_then(|metadata| metadata.modified().ok())
}
fn current_config_mtime() -> Option<SystemTime> {
folder_auto_banner::state::Config::config_path()
.ok()
.and_then(|path| std::fs::metadata(path).ok())
.and_then(|metadata| metadata.modified().ok())
}
fn cache_entry_is_fresh(entry: &CacheEntry, path: &Path) -> bool {
entry.computed_at.elapsed() < CACHE_TTL
&& entry.root_mtime == current_dir_mtime(path)
&& entry.config_mtime == current_config_mtime()
}
fn compute_dir_size_with_status(path: &Path, timeout: Duration) -> SizeComputation {
let path_arg = path.to_string_lossy();
if let Ok(stdout) = folder_auto_banner::utils::run_with_timeout_stdout(
"du",
&["-s", "-b", "--", path_arg.as_ref()],
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 SizeComputation {
size,
measured: true,
};
}
}
}
let size = std::fs::metadata(path).map(|m| m.len()).unwrap_or(0);
SizeComputation {
size,
measured: false,
}
}
fn cached_dir_size_is_fresh(
path: &Path,
cached_size: u64,
cached_mtime: Option<SystemTime>,
) -> bool {
if cached_mtime != current_dir_mtime(path) {
return false;
}
std::fs::metadata(path)
.map(|metadata| {
!(metadata.is_dir() && cached_size == metadata.len() && cached_size <= 4096)
})
.unwrap_or(false)
}
#[derive(serde::Serialize, serde::Deserialize)]
struct PersistedSizeCache {
sizes: HashMap<String, u64>,
mtimes: HashMap<String, Option<u128>>,
}
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 system_time_to_nanos(time: Option<SystemTime>) -> Option<u128> {
time.and_then(|time| time.duration_since(UNIX_EPOCH).ok())
.map(|duration| duration.as_nanos())
}
fn nanos_to_system_time(nanos: u128) -> Option<SystemTime> {
let secs = nanos / 1_000_000_000;
let subsec_nanos = nanos % 1_000_000_000;
if secs > u64::MAX as u128 {
return None;
}
UNIX_EPOCH.checked_add(Duration::new(secs as u64, subsec_nanos as u32))
}
fn load_size_cache(
socket_dir: &Path,
) -> (HashMap<PathBuf, u64>, HashMap<PathBuf, Option<SystemTime>>) {
let path = size_cache_path(socket_dir);
if let Ok(data) = std::fs::read_to_string(&path) {
if let Ok(persisted) = serde_json::from_str::<PersistedSizeCache>(&data) {
let sizes: HashMap<PathBuf, u64> = persisted
.sizes
.into_iter()
.map(|(k, v)| (PathBuf::from(k), v))
.collect();
let mtimes: HashMap<PathBuf, Option<SystemTime>> = persisted
.mtimes
.into_iter()
.map(|(k, v)| (PathBuf::from(k), v.and_then(nanos_to_system_time)))
.collect();
tracing::info!("Loaded {} cached directory sizes from disk", sizes.len());
return (sizes, mtimes);
}
if let Ok(map) = serde_json::from_str::<HashMap<String, u64>>(&data) {
let sizes: HashMap<PathBuf, u64> = map
.into_iter()
.map(|(k, v)| (PathBuf::from(k), v))
.collect();
tracing::info!("Loaded {} cached directory sizes from disk", sizes.len());
return (sizes, HashMap::new());
}
}
(HashMap::new(), HashMap::new())
}
fn save_size_cache(
socket_dir: &Path,
sizes: &HashMap<PathBuf, u64>,
mtimes: &HashMap<PathBuf, Option<SystemTime>>,
) {
let path = size_cache_path(socket_dir);
let persisted = PersistedSizeCache {
sizes: sizes
.iter()
.map(|(k, v)| (k.to_string_lossy().to_string(), *v))
.collect(),
mtimes: mtimes
.iter()
.map(|(k, v)| (k.to_string_lossy().to_string(), system_time_to_nanos(*v)))
.collect(),
};
if let Ok(data) = serde_json::to_string(&persisted) {
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 main() -> Result<()> {
let args: Vec<String> = std::env::args().collect();
if args.iter().any(|a| a == "--version" || a == "-V") {
println!("fabd {}", env!("CARGO_PKG_VERSION"));
return Ok(());
}
if args.iter().any(|a| a == "--help" || a == "-h") {
println!(
"fabd {}\nBackground daemon for folder-auto-banner\n\nUsage: fabd [OPTIONS]\n\nOptions:\n -h, --help Print help\n -V, --version Print version",
env!("CARGO_PKG_VERSION")
);
return Ok(());
}
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_should_skip_dir() {
assert!(should_skip_dir(Path::new("/home/user/project/.pi")));
assert!(should_skip_dir(Path::new("/home/user/project/.opencode")));
assert!(should_skip_dir(Path::new("/home/user/project/.claude")));
assert!(should_skip_dir(Path::new("/home/user/project/.cursor")));
assert!(should_skip_dir(Path::new("/home/user/project/target")));
assert!(should_skip_dir(Path::new(
"/home/user/project/node_modules"
)));
assert!(should_skip_dir(Path::new("/home/user/project/dist")));
assert!(should_skip_dir(Path::new("/home/user/project/build")));
assert!(should_skip_dir(Path::new("/home/user/project/.git")));
assert!(!should_skip_dir(Path::new("/home/user/project/src")));
assert!(!should_skip_dir(Path::new("/home/user/project/tests")));
assert!(!should_skip_dir(Path::new("/home/user/project/docs")));
}
#[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(),
root_mtime: None,
config_mtime: None,
};
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), root_mtime: None,
config_mtime: None,
};
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_with_status(tmp.path(), Duration::from_secs(5)).size;
assert!(size > 0);
}
#[test]
fn test_cached_snapshot_is_fresh_detects_new_item() {
let tmp = tempfile::tempdir().unwrap();
std::fs::write(tmp.path().join("a.txt"), "a").unwrap();
let summary = shallow_snapshot(tmp.path()).unwrap();
assert!(cached_snapshot_is_fresh_from_snapshot(&summary, tmp.path()));
std::fs::write(tmp.path().join("b.txt"), "b").unwrap();
assert!(!cached_snapshot_is_fresh_from_snapshot(
&summary,
tmp.path()
));
}
#[test]
fn test_cached_snapshot_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 = shallow_snapshot(tmp.path()).unwrap();
assert!(cached_snapshot_is_fresh_from_snapshot(&summary, tmp.path()));
std::thread::sleep(Duration::from_millis(20));
std::fs::write(child.join("nested-new.txt"), "after").unwrap();
assert!(!cached_snapshot_is_fresh_from_snapshot(
&summary,
tmp.path()
));
}
fn cached_snapshot_is_fresh_from_snapshot(cached: &ShallowSnapshot, path: &Path) -> bool {
let Ok(fresh) = shallow_snapshot(path) else {
return false;
};
*cached == fresh
}
#[test]
fn test_cached_placeholder_dir_size_is_retried() {
let tmp = tempfile::tempdir().unwrap();
let child = tmp.path().join("child");
std::fs::create_dir(&child).unwrap();
std::fs::write(child.join("payload.bin"), vec![7; 100_000]).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: 4096,
modified: None,
perms: String::new(),
owner: String::new(),
group: String::new(),
symlink_target: None,
symlink_valid: true,
content_probe: None,
}];
let dir_sizes = Arc::new(Mutex::new(HashMap::new()));
let dir_size_mtimes = Arc::new(Mutex::new(HashMap::new()));
let placeholder_size = std::fs::metadata(&child).unwrap().len();
dir_sizes
.lock()
.unwrap()
.insert(child.clone(), placeholder_size);
dir_size_mtimes
.lock()
.unwrap()
.insert(child.clone(), current_dir_mtime(&child));
refresh_displayed_dir_sizes(
&mut items,
&dir_sizes,
&dir_size_mtimes,
Duration::from_secs(5),
);
assert!(items[0].size > placeholder_size);
}
#[test]
fn test_compute_dir_size_reports_fallback_as_unmeasured() {
let computed = compute_dir_size_with_status(
Path::new("/tmp/definitely-missing-folder-auto-banner-dir"),
Duration::from_millis(1),
);
assert_eq!(computed.size, 0);
assert!(!computed.measured);
}
#[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,
content_probe: None,
}];
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,
Duration::from_secs(5),
);
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,
Duration::from_secs(5),
);
assert!(items[0].size > first_size);
}
}