fsmon 0.4.6

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

use anyhow::Result;
use fsmon::filters::PathOptions;
use fsmon::monitored::PathEntry;
use std::path::PathBuf;

mod add;
mod changes;
mod clean;
mod daemon;
mod health;
mod init_cd;
mod monitored;
mod query;
mod remove;

pub use add::cmd_add;
pub use changes::cmd_changes;
pub use clean::cmd_clean;
pub use daemon::{DaemonOptions, cmd_daemon};
pub use health::cmd_health;
pub use init_cd::{cmd_cd, cmd_init};
pub use monitored::{cmd_list_monitored_paths, cmd_monitored};
pub use query::cmd_query;
pub use remove::cmd_remove;

/// Top-level dispatch: match command enum and call the corresponding handler.
pub fn run(command: crate::Commands) -> Result<()> {
    use crate::Commands::*;
    match command {
        Daemon {
            debug,
            cache_dir_cap,
            cache_dir_ttl,
            cache_file_size,
            cache_proc_ttl,
            cache_stats_interval,
            buffer_size,
            channel_capacity,
            subscribe_buf,
            disk_min_free,
            sync_interval,
            local_time,
            metrics_interval,
            watchdog_interval,
            watchdog_multiplier,
        } => {
            let cli_cache = fsmon::config::CliCacheOverride {
                dir_capacity: cache_dir_cap,
                dir_ttl_secs: cache_dir_ttl,
                file_size_capacity: cache_file_size,
                proc_ttl_secs: cache_proc_ttl,
                stats_interval_secs: cache_stats_interval,
                buffer_size,
                channel_capacity,
                subscribe_buf,
            };
            cmd_daemon(DaemonOptions {
                debug,
                cli_cache,
                disk_min_free,
                sync_interval,
                local_time,
                metrics_interval,
                watchdog_interval,
                watchdog_multiplier,
            })
            .await_()
        }
        Add(args) => cmd_add(args),
        Remove { cmd, path } => cmd_remove(cmd, path),
        Monitored => cmd_monitored(),
        Query(args) => cmd_query(args).await_(),
        Changes(args) => cmd_changes(args).await_(),
        Clean(args) => cmd_clean(args).await_(),
        Init { service } => cmd_init(service),
        Cd { monitored, .. } => cmd_cd(monitored),
        Health => cmd_health(),
        ListMonitoredPaths => cmd_list_monitored_paths(),
    }
}

/// Convert async functions to sync by running in a new runtime.
/// Used because `run()` is called from sync `main()`.
trait AsyncPolyfill {
    type Output;
    fn await_(self) -> Self::Output;
}

impl<T> AsyncPolyfill for T
where
    T: std::future::Future<Output = Result<()>>,
{
    type Output = Result<()>;
    fn await_(self) -> Self::Output {
        tokio::runtime::Runtime::new()
            .map_err(|e| anyhow::anyhow!(e))?
            .block_on(self)
    }
}

/// Convert `PathEntry` list to `(PathBuf, PathOptions)` pairs.
pub fn parse_path_entries(entries: &[PathEntry]) -> Result<Vec<(PathBuf, PathOptions)>> {
    let mut result = Vec::new();
    for entry in entries {
        let opts = parse_path_options(entry)?;
        result.push((entry.path.clone(), opts));
    }
    Ok(result)
}

/// Convert a single `PathEntry` to `PathOptions`.
pub fn parse_path_options(entry: &PathEntry) -> Result<PathOptions> {
    PathOptions::try_from(entry)
}

/// Resolve a user-provided path to absolute.
/// Tilde expansion → path clean → canonicalize if exists,
/// otherwise join relative paths with cwd.
pub fn resolve_path_arg(raw: &std::path::Path) -> std::path::PathBuf {
    use path_clean::PathClean;
    let home = std::env::var("HOME").unwrap_or_else(|_| "/root".to_string());
    let expanded = fsmon::config::expand_tilde(raw, &home);
    let cleaned = expanded.clean();
    match cleaned.canonicalize() {
        Ok(c) => c,
        Err(_) => {
            if cleaned.is_relative() {
                std::env::current_dir()
                    .map(|cwd| cwd.join(&cleaned))
                    .unwrap_or(cleaned)
            } else {
                cleaned
            }
        }
    }
}