rsincron 0.0.6

Rust rewrite of the incredibly useful but abandoned incron software
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

use crate::handler_config::HandlerConfig;
use inotify::{EventStream, Inotify, WatchDescriptor, WatchMask};
use log::{debug, info, warn};
use std::{
    collections::{HashMap, HashSet},
    error,
    path::PathBuf,
};
use walkdir::WalkDir;

#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub struct WatchConfig {
    pub recursive: bool,
}

impl Default for WatchConfig {
    fn default() -> Self {
        Self { recursive: false }
    }
}

pub type Watch = (String, WatchMask, String, WatchConfig);
pub type Watches = HashMap<WatchDescriptor, Watch>;
pub type FailedWatches = HashSet<Watch>;

pub enum AddWatchError {
    PathToStr,
    FolderDoesntExit,
}

pub struct Handler {
    pub inotify: Inotify,
    pub active_watches: Watches,
    pub failed_watches: FailedWatches,
    pub handler_config: HandlerConfig,
}

impl Handler {
    pub fn new() -> Result<Self, Box<dyn error::Error>> {
        Ok(HandlerConfig::default().setup()?)
    }

    pub fn add_watch(
        &mut self,
        (file_path, mask, command, watch_config): Watch,
        folder_name: Option<String>,
    ) -> Result<(), AddWatchError> {
        debug!("watch add: {file_path}");
        let mut pathbuf = PathBuf::from(file_path);

        if let Some(folder_name) = folder_name {
            pathbuf.push(folder_name.to_string());
        };

        let Some(path) = pathbuf.to_str() else {
            return Err(AddWatchError::PathToStr)
        };

        let Ok(descriptor) = self.inotify.add_watch(&path.to_string(), mask) else {
            self.failed_watches.insert((path.to_string(), mask, command, watch_config));
            warn!("watch setup failed: {} for masks {:?}", path, mask);
            return Err(AddWatchError::FolderDoesntExit)
        };

        info!("watch setup: {} for masks {:?}", path, mask);
        self.active_watches.entry(descriptor).or_insert((
            path.to_string(),
            mask,
            command,
            watch_config,
        ));

        Ok(())
    }

    pub fn get_event_stream(&mut self) -> EventStream<[u8; 1024]> {
        let buffer = [0; 1024];
        self.inotify
            .event_stream(buffer)
            .expect("error opening event stream: exiting")
    }

    pub fn recursive_add_watch(&mut self, (file_path, mask, command, watch_config): Watch) {
        for entry in WalkDir::new(file_path)
            .min_depth(1)
            .into_iter()
            .filter_entry(|e| e.file_type().is_dir())
        {
            let Ok(entry) = entry else {
                    continue;
                };

            let Some(path) = entry.path().to_str() else {
                    continue;
                };

            let watch = (path.to_string(), mask, command.clone(), watch_config);
            match self.add_watch(watch.clone(), None) {
                Err(_) => self.failed_watches.insert(watch),
                _ => true,
            };
        }
    }
}