processmon 0.4.1

Process monitor that can run trigger scripts and subsequently restarts the process when files on specified paths are modified.
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

use std::env;
use std::path::{Path,PathBuf};

use crate::config::Config;

pub struct Ignore {
    paths: Vec<PathBuf>
}

impl Ignore {
    pub fn new(config: &Config) -> Self {
        let mut paths = Vec::new();

        // Collect full list of paths to ignore
        for path_config in config.paths_to_watch.iter() {
            match path_config.ignore {
                Some(ref ignore) => {
                    let path = Path::new(&path_config.path).to_path_buf();
                    // See if this is a root path, or if we should
                    // prefix it with the working directory
                    let path = if path.has_root() {
                        path
                    } else {
                        let current_dir = env::current_dir().expect("Could not get current dir");
                        current_dir.join(path).to_path_buf()
                    };
                    for ignore_path in ignore.iter() {
                        let ignore_path = Path::new(ignore_path);
                        let combined_path = path.join(ignore_path).to_path_buf();
                        paths.push(combined_path);
                    }
                },
                None => ()
            }
        }

        Self {
            paths: paths
        }
    }

    pub fn should_ignore(&self, path: &Path) -> bool {
        for ignore_path in self.paths.iter() {
            if path.starts_with(ignore_path) {
                return true
            }
        }
        false
    }
}

#[cfg(test)]
mod tests {
    use std::collections::HashMap;
    use super::*;

    #[test]
    fn test_ignore_with_root_path() {
        let config = helpers::mock_config("/path", "tmp");
        let ignore = Ignore::new(&config);

        // Don't ignore these
        assert!(!ignore.should_ignore(&Path::new("something")));
        assert!(!ignore.should_ignore(&Path::new("/path/something")));

        // Ignore these
        assert!(ignore.should_ignore(&Path::new("/path/tmp")));
        assert!(ignore.should_ignore(&Path::new("/path/tmp/some_file.txt")));
    }

    #[test]
    fn test_ignore_wth_relative_path() {
        let current_dir = env::current_dir().unwrap();

        let config = helpers::mock_config("path", "tmp");
        let ignore = Ignore::new(&config);

        // Don't ignore these
        assert!(!ignore.should_ignore(&Path::new("something")));
        assert!(!ignore.should_ignore(&current_dir.join("path/something")));

        // Ignore these
        assert!(ignore.should_ignore(&current_dir.join("path/tmp")));
        assert!(ignore.should_ignore(&current_dir.join("path/tmp/some_file.txt")));
    }

    mod helpers {
        use super::*;
        use crate::config::PathConfig;

        pub fn mock_config(path: &str, ignore: &str) -> Config {
            let paths_to_watch = vec![
                PathConfig {
                    path: path.to_owned(),
                    ignore: Some(vec![ignore.to_owned()])
                }
            ];
            Config {
                paths_to_watch: paths_to_watch,
                processes: HashMap::new(),
                triggers: None,
                debug_mode: None
            }
        }
    }
}