petrichor 0.1.0

Hackathon project
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

#![feature(proc_macro_hygiene, decl_macro)]
extern crate rocket;
extern crate serde_json;
use serde_json::{to_string, from_str};

use rocket_contrib::json::{Json, JsonValue};

pub fn stdio_to_json<F: Fn(Vec<u8>) -> JsonValue>(
    cmd_path : &str,
    args : &[&str],
    validated_json : Json<JsonValue>,
    f : F
    ) -> JsonValue {
    use std::io::Write;
    use rocket_contrib::json;
    let json_str = to_string(&validated_json.into_inner()).unwrap();
    let command = std::process::Command::new(cmd_path)
        .args(args)
        .stdin(std::process::Stdio::piped())
        .stdout(std::process::Stdio::piped())
        .stderr(std::process::Stdio::piped())
        .spawn();
    let mut command = match command {
        Err(_) => { return json! {{ "error" : "Failed to run command!" }}},
        Ok(command) => command
    };
    if write!(command.stdin.as_mut().unwrap(), "{}", json_str).is_err() {
        return json! {{ "error" : "Could not write to pipe" }}
    }
    match command.wait_with_output() {
        Err(_) => {
            json! {{ "error" : "Couldn't wait for command" }}
        },
        Ok(output) => if output.status.success() {
            f(output.stdout)
        } else {
            let error_text = match String::from_utf8(output.stderr) {
                Ok(error_text) => error_text,
                Err(_) => "Error text is not valid UTF-8, cannot display!".to_owned()
            };
            match output.status.code() {
                Some(code) => json! {{
                    "error_code" : code,
                    "error" : error_text
                }},
                None => json! {{
                    "error" : error_text
                }}
            }
        }
    }
}

pub fn json_or_error(data : Vec<u8>) -> JsonValue {
    use rocket_contrib::json;
    match String::from_utf8(data) {
        Ok(text) => {
            match from_str(&text) {
                Ok(json) => json,
                Err(_) => json! {{ "error" : "Application output invalid JSON!" }}
            }
        },
        Err(_) => json! {{ "error" : "Application did not output valid UTF-8" }}
    }
}

pub fn json_named(name : &'static str) -> impl Fn(Vec<u8>) -> JsonValue {
    use rocket_contrib::json;
    move |data : Vec<u8>| {
        match String::from_utf8(data) {
            Ok(text) => json ! {{ name : text }},
            Err(_) => json! {{ "error" : "Application did not output valid UTF-8" }}
        }
    }
}

#[macro_export]
macro_rules! stdio_handler {
    (let $name:ident = $path:literal -> wrap $cmd_path:expr, $args:expr ; ) => {
        #[post($path, data="<validated_json>")]
        pub fn $name(
            validated_json : rocket_contrib::json::Json<rocket_contrib::json::JsonValue>)
            -> rocket_contrib::json::JsonValue {

            petri::stdio_to_json(
                $cmd_path,
                &($args),
                validated_json,
                petri::json_or_error
            )

        }
    };
    (
        let $name:ident = $path:literal ->
        read $attrib:literal from $cmd_path:expr, $args:expr ;
    ) => {
        #[post($path, data="<validated_json>")]
        pub fn $name(
            validated_json : rocket_contrib::json::Json<rocket_contrib::json::JsonValue>)
            -> rocket_contrib::json::JsonValue {

            petri::stdio_to_json(
                $cmd_path,
                &($args),
                validated_json,
                petri::json_named($attrib)
            )

        }
    };
    () => {}
}

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }
}