fsmon 0.4.1

Lightweight High-Performance File System Change Tracking Tool
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use anyhow::{Context, Result};
use fsmon::DaemonLock;
use fsmon::config::{CacheConfig, CliCacheOverride, Config};
use fsmon::monitor::Monitor;
use fsmon::monitored::Monitored;
use std::fs;
use std::path::Path;

use super::parse_path_entries;

pub async fn cmd_daemon(
    debug: bool,
    cli_cache: CliCacheOverride,
    disk_min_free: Option<String>,
    sync_interval: Option<u64>,
    local_time: bool,
) -> Result<()> {
    // Acquire singleton lock first — only one daemon instance allowed
    let (uid, _gid) = fsmon::config::resolve_uid_gid();
    let _lock = DaemonLock::acquire(uid)?;

    let mut cfg = Config::load()?;
    cfg.resolve_paths()?;

    eprintln!("Config loaded:");
    eprintln!(
        "  Monitored path database:  {}",
        cfg.monitored.path.display()
    );
    // Log path comes purely from config
    let log_path = cfg.logging.path.clone();
    if let Some(ref p) = log_path {
        eprintln!("  Event logs:     {}", p.display());
    } else {
        eprintln!("  Event logs:     disabled (path not configured)");
    }
    eprintln!("  Command socket: {}", cfg.socket.path.display());

    let store = Monitored::load(&cfg.monitored.path)?;

    let socket_path = cfg.socket.path.clone();

    // Create parent directories for socket
    if socket_path.exists() {
        fs::remove_file(&socket_path)?;
    }
    if let Some(parent) = socket_path.parent() {
        fs::create_dir_all(parent)?;
    }

    let socket_listener = tokio::net::UnixListener::bind(&socket_path)
        .with_context(|| format!("Failed to bind socket at {}", socket_path.display()))?;

    // Set socket permissions to 0666 so any user can send commands
    set_socket_permissions(&socket_path)?;

    // Chown store parent dir to the original user (daemon runs as root)
    if let Some(parent) = cfg.monitored.path.parent() {
        fsmon::config::chown_to_original_user(parent);
    }

    // Merge cache config: CLI > fsmon.toml > code defaults
    let cache_cfg = cfg
        .cache
        .as_ref()
        .map(|c| c.resolve_with_cli(&cli_cache))
        .unwrap_or_else(|| {
            let empty = CacheConfig {
                dir_capacity: None,
                dir_ttl_secs: None,
                file_size_capacity: None,
                proc_ttl_secs: None,
                stats_interval_secs: None,
                channel_capacity: None,
                subscribe_buf: None,
            };
            empty.resolve_with_cli(&cli_cache)
        });

    if debug {
        eprintln!("[DEBUG] --- cache configuration ---");
        eprintln!("[DEBUG]   dir_capacity:       {}", cache_cfg.dir_capacity);
        eprintln!("[DEBUG]   dir_ttl_secs:       {}", cache_cfg.dir_ttl_secs);
        eprintln!("[DEBUG]   file_size_capacity: {}", cache_cfg.file_size_capacity);
        eprintln!("[DEBUG]   proc_ttl_secs:      {}", cache_cfg.proc_ttl_secs);
        eprintln!("[DEBUG]   stats_interval_secs: {}", cache_cfg.stats_interval_secs);
        eprintln!("[DEBUG]   buffer_size:        {}", cache_cfg.buffer_size);
        match cache_cfg.channel_capacity {
            Some(cap) => eprintln!("[DEBUG]   channel_capacity:   {} (bounded)", cap),
            None => eprintln!("[DEBUG]   channel_capacity:   unbounded"),
        }
    }

    let paths_and_options = parse_path_entries(&store.flatten())?;

    // Merge disk_min_free: CLI > config > None
    let disk_min_free = disk_min_free
        .or_else(|| cfg.logging.disk_min_free.clone());

    // Merge sync_interval: CLI > config > None (disabled)
    let sync_interval = sync_interval
        .or(cfg.logging.sync_interval_secs)
        .filter(|&n| n > 0)
        .map(std::time::Duration::from_secs);

    if debug {
        if let Some(d) = sync_interval {
            eprintln!("[DEBUG]   sync_interval:      {}s", d.as_secs());
        } else {
            eprintln!("[DEBUG]   sync_interval:      disabled");
        }
    }

    let store_path = cfg.monitored.path.clone();
    let subscribe_buf = cache_cfg.subscribe_buf;
    let log_dir = log_path;
    if debug {
        eprintln!("[DEBUG]   local logging:      {}", if log_dir.is_some() { "enabled" } else { "disabled" });
    }
    let mut monitor = Monitor::new(
        paths_and_options,
        log_dir,
        Some(store_path),
        Some(cache_cfg.buffer_size),
        Some(socket_listener),
        debug,
        Some(cache_cfg),
        disk_min_free,
        sync_interval,
        Some(subscribe_buf),
        local_time || cfg.logging.local_time.unwrap_or(false),
    )?;

    if !store.is_empty() {
        for group in &store.groups {
            let cmd_label = if group.cmd == fsmon::monitored::CMD_GLOBAL {
                "[global]".to_string()
            } else {
                format!("[{}]", group.cmd)
            };
            eprintln!("  {} ({} path(s)):", cmd_label, group.paths.len());
            for path in group.paths.keys() {
                eprintln!("    {}", path.display());
            }
        }
    }

    monitor.run().await?;
    Ok(())
}

/// Set socket permissions to 0666 so non-root users can communicate with the daemon.
pub fn set_socket_permissions(path: &Path) -> Result<()> {
    use std::os::unix::fs::PermissionsExt;
    let perm = fs::Permissions::from_mode(0o666);
    fs::set_permissions(path, perm)
        .with_context(|| format!("Failed to set socket permissions on {}", path.display()))?;
    Ok(())
}