iowatchd 0.5.2

Monitors disk IO usage and logs which processes are consuming it
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

//! User notification hook: runs the configured `notify_command` when an alert
//! starts or IO recovers. The command runs in the background so the monitor
//! loop is never blocked.

use std::process::{Command, Stdio};
use std::time::{Duration, Instant};

/// A hook that runs longer than this is killed.
const HOOK_TIMEOUT: Duration = Duration::from_secs(30);

/// Information passed to the hook as environment variables.
pub struct HookEvent<'a> {
    /// `alert` or `normal`.
    pub event: &'a str,
    pub device: &'a str,
    pub util: f64,
    /// The same human-readable text that was logged.
    pub message: &'a str,
}

/// Runs `command` through `sh -c` with:
/// `IOWATCHD_EVENT`, `IOWATCHD_DEVICE`, `IOWATCHD_UTIL` and `IOWATCHD_MESSAGE`.
/// Failures are reported on stderr and never stop the monitor.
pub fn run_hook(command: &str, ev: &HookEvent) {
    let spawned = Command::new("sh")
        .arg("-c")
        .arg(command)
        .env("IOWATCHD_EVENT", ev.event)
        .env("IOWATCHD_DEVICE", ev.device)
        .env("IOWATCHD_UTIL", format!("{:.0}", ev.util))
        .env("IOWATCHD_MESSAGE", ev.message)
        .stdin(Stdio::null())
        .stdout(Stdio::null())
        .stderr(Stdio::null())
        .spawn();
    let mut child = match spawned {
        Ok(c) => c,
        Err(e) => return eprintln!("warning: could not run notify_command: {e}"),
    };
    // Reap the child (no zombies) and enforce the timeout off the main thread.
    std::thread::spawn(move || {
        let start = Instant::now();
        loop {
            match child.try_wait() {
                Ok(Some(_)) | Err(_) => return,
                Ok(None) if start.elapsed() > HOOK_TIMEOUT => {
                    let _ = child.kill();
                    let _ = child.wait();
                    return;
                }
                Ok(None) => std::thread::sleep(Duration::from_millis(200)),
            }
        }
    });
}

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

    #[test]
    fn hook_receives_the_environment() {
        let out = std::env::temp_dir().join(format!("iowatchd-hook-{}", std::process::id()));
        let cmd = format!(
            "echo \"$IOWATCHD_EVENT $IOWATCHD_DEVICE $IOWATCHD_UTIL $IOWATCHD_MESSAGE\" > {}",
            out.display()
        );
        run_hook(
            &cmd,
            &HookEvent {
                event: "alert",
                device: "sda",
                util: 97.4,
                message: "hello world",
            },
        );
        for _ in 0..50 {
            if out.exists() {
                std::thread::sleep(Duration::from_millis(100));
                break;
            }
            std::thread::sleep(Duration::from_millis(100));
        }
        let text = std::fs::read_to_string(&out).unwrap_or_default();
        let _ = std::fs::remove_file(&out);
        assert_eq!(text.trim(), "alert sda 97 hello world");
    }

    fn ev() -> HookEvent<'static> {
        HookEvent {
            event: "normal",
            device: "sda",
            util: 5.0,
            message: "ok",
        }
    }

    #[test]
    fn failing_and_missing_commands_do_not_panic() {
        run_hook("exit 3", &ev());
        run_hook("this-command-does-not-exist-iowatchd", &ev());
        run_hook("", &ev());
    }

    #[test]
    fn hook_does_not_block_the_caller() {
        let start = Instant::now();
        run_hook("sleep 5", &ev());
        assert!(start.elapsed() < Duration::from_secs(2));
    }
}