deoxy 0.2.1

A programmable, user-friendly buffer exchange system.
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

//! Contains utilities for sending email notifications.

use std::{
    io::{BufWriter, Write},
    process::{Command, Stdio},
};

/// Encodes the status of the decell machine.
#[derive(Clone, Copy, Debug)]
pub enum Status<'a> {
    /// The run has finished.
    Finished,
    /// The run has been aborted.
    Aborted,
    /// A custom status message.
    Custom {
        /// The message's subject.
        subject: &'a str,
        /// The message's body.
        message: &'a str,
    },
}

/// Notify the specified recipients of a status change.
pub fn notify(to: &[impl ToString], status: Status) -> std::io::Result<()> {
    let (subject, message) = match status {
        Status::Finished => (
            "Completed",
            "The decellularization run has completed as scheduled.",
        ),
        Status::Aborted => (
            "Aborted",
            "The decellularization run has been aborted manually.",
        ),
        Status::Custom { subject, message } => (subject, message),
    };
    mail(to, subject, message)
}

/// Send an email to the specified recipients.
// Thanks to BurntSushi.
pub fn mail(
    to: &[impl ToString],
    subject: impl ToString,
    message: impl ToString,
) -> std::io::Result<()> {
    let mut child = Command::new("sendmail")
        .arg("-t")
        .stdin(Stdio::piped())
        .spawn()?;
    {
        let mut buf = BufWriter::new(child.stdin.as_mut().unwrap());
        writeln!(
            &mut buf,
            "\
Subject: {subject}
From: deoxy@hmltn.me",
            subject = subject.to_string()
        )?;
        for recipient in to {
            writeln!(&mut buf, "To: {}", recipient.to_string())?;
        }
        writeln!(&mut buf)?;
        writeln!(&mut buf, "{}", message.to_string())?;
        writeln!(&mut buf, ".")?;
    }
    let status = child.wait()?;
    if status.success() {
        Ok(())
    } else {
        Err(match status.code() {
            None => {
                std::io::Error::new(std::io::ErrorKind::Interrupted, "Email sending interrupted")
            }
            Some(_) => std::io::Error::new(std::io::ErrorKind::Other, status.to_string()),
        })
    }
}