Merge pull request #1 from bruceadams/proposal

Proposed changes to action_loop

Author: sciabarracom

rust1.32/src/Cargo.lock

@@ -2,8 +2,11 @@
 name = "action_loop"
 version = "0.1.0"
 authors = ["Roberto Diaz <roberto@theagilemonkeys.com>"]
+edition = "2018"
 
 [dependencies]
+serde = "1.0"
+serde_derive = "1.0"
 serde_json = "1.0"
 libc = "0.2.49"
-actions = { path = "../actions" }
+actions = { path = "../actions" }

rust1.32/src/action_loop/Cargo.toml

@@ -1,49 +1,46 @@
-extern crate serde_json;
-extern crate actions;
-extern crate libc;
-
-use std::env;
-use std::io::{self, Write, stdout, stderr};
-use std::fs::File;
-use std::os::unix::io::FromRawFd;
-use std::collections::HashMap;
-use serde_json::{Value, Error};
 use actions::main as actionMain;
 
+use serde_derive::Deserialize;
+use serde_json::{Error, Value};
+use std::{
+    collections::HashMap,
+    env,
+    fs::File,
+    io::{stderr, stdin, stdout, BufRead, Write},
+    os::unix::io::FromRawFd,
+};
+
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+struct Input {
+    value: HashMap<String, Value>,
+    #[serde(flatten)]
+    environment: HashMap<String, Value>,
+}
+
 fn main() {
-    let mut fd3 = unsafe { File::from_raw_fd(3)};
-    loop {
-        let mut buffer = String::new();
-        io::stdin().read_line(&mut buffer).unwrap();
-        let parsed_input:Result<HashMap<String,Value>,Error> = serde_json::from_str(&buffer);
-        let mut payload:HashMap<String, Value> = HashMap::new();
+    let mut fd3 = unsafe { File::from_raw_fd(3) };
+    let stdin = stdin();
+    for line in stdin.lock().lines() {
+        let buffer: String = line.expect("Error reading line");
+        let parsed_input: Result<Input, Error> = serde_json::from_str(&buffer);
         match parsed_input {
-            Ok(n) => {
-                for (key, val) in n {
-                    if key == "value" {
-                        let mut unparsed_payload:Result<HashMap<String,Value>,Error> = serde_json::from_value(val);
-                        match unparsed_payload {
-                            Ok(value) => payload = value,
-                            Err(err) => {
-                                eprintln!("Error parsing value json: {}", err);
-                                continue
-                            }
-                        }
-                    } else {
-                        env::set_var(format!("__OW_{}", key.to_uppercase()), val.to_string());
+            Ok(input) => {
+                for (key, val) in input.environment {
+                    env::set_var(format!("__OW_{}", key.to_uppercase()), val.to_string());
+                }
+                match serde_json::to_string(&actionMain(input.value)) {
+                    Ok(result) => {
+                        writeln!(&mut fd3, "{}", result).expect("Error writing on fd3");
+                    }
+                    Err(err) => {
+                        eprintln!("Error formatting result value json: {}", err);
                     }
                 }
             }
-            Err(e) =>{
-                eprintln!("Error: {}", e);
-                continue
+            Err(err) => {
+                eprintln!("Error parsing input: {}", err);
             }
         }
-        
-        match serde_json::to_string(&actionMain(payload)){
-            Ok(result) => { write!(&mut fd3, "{}\n", result).expect("Error writting on fd3");}
-            Err(err) => {  eprintln!("Error parsing resul value json: {}", err);}
-        }
         stdout().flush().expect("Error flushing stdout");
         stderr().flush().expect("Error flushing stderr");
     }