shikane 1.0.1

dynamic output configuration tool focusing on accuracy and determinism
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

use std::collections::HashMap;
use std::process::Command;

#[allow(unused_imports)]
use log::{debug, error, info, trace, warn};

#[derive(Clone, Debug)]
pub struct CommandBuilder {
    profile_name: String,
    profile_commands: Vec<String>,
    heads: HashMap<String, Vec<String>>,
    oneshot: bool,
}

impl CommandBuilder {
    pub fn new(profile_name: String) -> Self {
        Self {
            profile_name,
            profile_commands: Default::default(),
            heads: Default::default(),
            oneshot: false,
        }
    }
    pub fn oneshot(&mut self, oneshot: bool) {
        self.oneshot = oneshot
    }
    pub fn profile_commands(&mut self, profile_commands: Vec<String>) {
        self.profile_commands = profile_commands
    }
    pub fn insert_head_commands(&mut self, head_name: String, output_commands: Vec<String>) {
        self.heads.insert(head_name, output_commands);
    }

    pub fn execute(self) {
        let oneshot = self.oneshot;
        let mut cmd_list = self.create_command_list();
        if cmd_list.is_empty() {
            return;
        }

        trace!("starting command executer thread");
        let handle = std::thread::Builder::new()
            .name("command exec".into())
            .spawn(move || {
                cmd_list.iter_mut().for_each(|(exec, cmd)| {
                    execute_command(exec, cmd);
                });
            });

        if let Err(err) = handle {
            error!("cannot spawn thread {:?}", err);
            return;
        }

        // return immediately if we are running as a daemon
        if !oneshot {
            return;
        }

        if let Err(err) = handle.unwrap().join() {
            error!("cannot join thread {:?}", err)
        }
    }

    fn create_command_list(self) -> Vec<(String, Command)> {
        let mut cmd_list: Vec<(String, Command)> = vec![];
        let env_vars = vec![("SHIKANE_PROFILE_NAME", self.profile_name.as_str())];
        assemble_commands(&mut cmd_list, self.profile_commands, &env_vars);
        for (head_name, output_commands) in self.heads {
            let env_vars = vec![("SHIKANE_OUTPUT_NAME", head_name.as_str())];
            assemble_commands(&mut cmd_list, output_commands, &env_vars);
        }
        cmd_list
    }
}

fn assemble_commands(
    cmd_list: &mut Vec<(String, Command)>,
    vexec: Vec<String>,
    env_vars: &[(&str, &str)],
) {
    for cmd in vexec {
        let mut c = Command::new("sh");
        c.arg("-c").arg(cmd.clone());
        c.envs(env_vars.to_owned());
        cmd_list.push((cmd, c));
    }
}

fn execute_command(exec: &mut String, cmd: &mut Command) {
    debug!("[cmd] {:?}", exec);
    let output = match cmd.output() {
        Ok(o) => o,
        Err(err) => {
            error!("failed to spawn command: {:?} {}", exec, err);
            return;
        }
    };
    if let Ok(stdout) = String::from_utf8(output.stdout) {
        trace!("[stdout] {:?}", stdout)
    }
    if let Ok(stderr) = String::from_utf8(output.stderr) {
        trace!("[stderr] {:?}", stderr)
    }
}