Merge pull request #1179 from mikrostew/event-args

Add `Args` event to hold `argv`

Author: charlespierce

crates/volta-core/src/event.rs

@@ -3,22 +3,22 @@
 use std::env;
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
 use crate::error::{ExitCode, VoltaError};
 use crate::hook::Publish;
-use crate::monitor::Monitor;
+use crate::monitor::send_events;
 use crate::session::ActivityKind;
 
 // the Event data that is serialized to JSON and sent the plugin
-#[derive(Serialize)]
+#[derive(Deserialize, Serialize)]
 pub struct Event {
     timestamp: u64,
-    name: String,
-    event: EventKind,
+    pub name: String,
+    pub event: EventKind,
 }
 
-#[derive(Serialize)]
+#[derive(Deserialize, Serialize, PartialEq, Debug)]
 pub struct ErrorEnv {
     argv: String,
     exec_path: String,
@@ -27,9 +27,9 @@ pub struct ErrorEnv {
     platform_version: String,
 }
 
-#[derive(Serialize)]
+#[derive(Deserialize, Serialize, PartialEq, Debug)]
 #[serde(rename_all = "lowercase")]
-enum EventKind {
+pub enum EventKind {
     Start,
     End {
         exit_code: i32,
@@ -42,6 +42,9 @@ enum EventKind {
     ToolEnd {
         exit_code: i32,
     },
+    Args {
+        argv: String,
+    },
 }
 
 impl EventKind {
@@ -122,6 +125,18 @@ impl EventLog {
             activity_kind,
         )
     }
+    pub fn add_event_args(&mut self) {
+        let argv = env::args_os()
+            .enumerate()
+            .fold(String::new(), |mut result, (i, arg)| {
+                if i > 0 {
+                    result.push(' ');
+                }
+                result.push_str(&arg.to_string_lossy());
+                result
+            });
+        self.add_event(EventKind::Args { argv }, ActivityKind::Args)
+    }
 
     fn add_event(&mut self, event_kind: EventKind, activity_kind: ActivityKind) {
         let event = event_kind.into_event(activity_kind);
@@ -133,8 +148,7 @@ impl EventLog {
             // Note: This call to unimplemented is left in, as it's not a Fallible operation that can use ErrorKind::Unimplemented
             Some(&Publish::Url(_)) => unimplemented!(),
             Some(&Publish::Bin(ref command)) => {
-                let mut monitor = Monitor::new(command);
-                monitor.send_events(&self.events);
+                send_events(command, &self.events);
             }
             None => {}
         }
@@ -144,9 +158,10 @@ impl EventLog {
 #[cfg(test)]
 pub mod tests {
 
-    use super::EventLog;
+    use super::{EventKind, EventLog};
     use crate::error::{ErrorKind, ExitCode};
     use crate::session::ActivityKind;
+    use regex::Regex;
 
     #[test]
     fn test_adding_events() {
@@ -156,18 +171,41 @@ pub mod tests {
         event_log.add_event_start(ActivityKind::Current);
         assert_eq!(event_log.events.len(), 1);
         assert_eq!(event_log.events[0].name, "current");
+        assert_eq!(event_log.events[0].event, EventKind::Start);
 
         event_log.add_event_end(ActivityKind::Pin, ExitCode::NetworkError);
         assert_eq!(event_log.events.len(), 2);
         assert_eq!(event_log.events[1].name, "pin");
+        assert_eq!(event_log.events[1].event, EventKind::End { exit_code: 5 });
 
         event_log.add_event_tool_end(ActivityKind::Version, 12);
         assert_eq!(event_log.events.len(), 3);
         assert_eq!(event_log.events[2].name, "version");
+        assert_eq!(
+            event_log.events[2].event,
+            EventKind::ToolEnd { exit_code: 12 }
+        );
 
         let error = ErrorKind::BinaryExecError.into();
         event_log.add_event_error(ActivityKind::Install, &error);
         assert_eq!(event_log.events.len(), 4);
         assert_eq!(event_log.events[3].name, "install");
+        // not checking the error because it has too much machine-specific info
+
+        event_log.add_event_args();
+        assert_eq!(event_log.events.len(), 5);
+        assert_eq!(event_log.events[4].name, "args");
+        match event_log.events[4].event {
+            EventKind::Args { ref argv } => {
+                let re = Regex::new("volta_core").unwrap();
+                assert!(re.is_match(argv));
+            }
+            _ => {
+                panic!(
+                    "Expected EventKind::Args {{ argv }}, Got: {:?}",
+                    event_log.events[4].event
+                );
+            }
+        }
     }
 }

crates/volta-core/src/lib.rs

@@ -2,7 +2,7 @@
 
 mod command;
 pub mod error;
-mod event;
+pub mod event;
 pub mod fs;
 mod hook;
 pub mod inventory;

crates/volta-core/src/monitor.rs

@@ -1,58 +1,82 @@
+use std::env;
 use std::io::Write;
+use std::path::PathBuf;
 use std::process::{Child, Stdio};
 
 use log::debug;
+use tempfile::NamedTempFile;
 
 use crate::command::create_command;
 use crate::event::Event;
 
-pub struct Monitor {
-    monitor_process: Option<Child>,
-}
-
-impl Monitor {
-    /// Returns the current monitor.
-    pub fn new(command: &str) -> Monitor {
-        Monitor {
-            monitor_process: spawn_process(command),
+/// Send event to the spawned command process
+// if hook command is not configured, this is not called
+pub fn send_events(command: &str, events: &[Event]) {
+    match serde_json::to_string_pretty(&events) {
+        Ok(events_json) => {
+            let tempfile_path = env::var_os("VOLTA_WRITE_EVENTS_FILE")
+                .and_then(|_| write_events_file(events_json.clone()));
+            if let Some(ref mut child_process) = spawn_process(command, tempfile_path) {
+                if let Some(ref mut p_stdin) = child_process.stdin.as_mut() {
+                    if let Err(error) = writeln!(p_stdin, "{}", events_json) {
+                        debug!("Could not write events to executable stdin: {:?}", error);
+                    }
+                }
+            }
+        }
+        Err(error) => {
+            debug!("Could not serialize events data to JSON: {:?}", error);
         }
     }
+}
 
-    /// send event to the monitor process
-    // if hook command is not configured, this is a no-op
-    pub fn send_events(&mut self, events: &[Event]) {
-        if let Some(ref mut child_process) = self.monitor_process {
-            if let Some(ref mut p_stdin) = child_process.stdin.as_mut() {
-                let json = serde_json::to_string(&events);
-
-                match json {
-                    Ok(data) => {
-                        // FIXME: tighten up this error message
-                        write!(p_stdin, "{}", data).expect("Writing data to plugin failed!");
-                    }
-                    Err(error) => {
-                        // FIXME: tighten up this error message
-                        debug!("There was a problem serializing the JSON data: {:?}", error);
+// Write the events JSON to a file in the temporary directory
+fn write_events_file(events_json: String) -> Option<PathBuf> {
+    match NamedTempFile::new() {
+        Ok(mut events_file) => {
+            match events_file.write_all(events_json.as_bytes()) {
+                Ok(()) => {
+                    let path = events_file.into_temp_path();
+                    // if it's not persisted, the temp file will be automatically deleted
+                    // (and the executable won't be able to read it)
+                    match path.keep() {
+                        Ok(tempfile_path) => Some(tempfile_path),
+                        Err(error) => {
+                            debug!("Failed to persist temp file for events data: {:?}", error);
+                            None
+                        }
                     }
-                };
+                }
+                Err(error) => {
+                    debug!("Failed to write events to the temp file: {:?}", error);
+                    None
+                }
             }
         }
+        Err(error) => {
+            debug!("Failed to create a temp file for events data: {:?}", error);
+            None
+        }
     }
 }
 
-fn spawn_process(command: &str) -> Option<Child> {
+// Spawn a child process to receive the events data, setting the path to the events file as an env var
+fn spawn_process(command: &str, tempfile_path: Option<PathBuf>) -> Option<Child> {
     command.split(' ').take(1).next().and_then(|executable| {
         let mut child = create_command(executable);
         child.args(command.split(' ').skip(1));
         child.stdin(Stdio::piped());
+        if let Some(events_file) = tempfile_path {
+            child.env("EVENTS_FILE", events_file);
+        }
 
         #[cfg(not(debug_assertions))]
         // Hide stdout and stderr of spawned process in release mode
         child.stdout(Stdio::null()).stderr(Stdio::null());
 
         match child.spawn() {
             Err(err) => {
-                debug!("Unable to run plugin command: '{}'\n{}", command, err);
+                debug!("Unable to run executable command: '{}'\n{}", command, err);
                 None
             }
             Ok(c) => Some(c),

crates/volta-core/src/session.rs

@@ -36,6 +36,7 @@ pub enum ActivityKind {
     Which,
     Setup,
     Run,
+    Args,
 }
 
 impl Display for ActivityKind {
@@ -62,6 +63,7 @@ impl Display for ActivityKind {
             ActivityKind::Completions => "completions",
             ActivityKind::Which => "which",
             ActivityKind::Run => "run",
+            ActivityKind::Args => "args",
         };
         f.write_str(s)
     }
@@ -145,12 +147,20 @@ impl Session {
     }
 
     fn publish_to_event_log(self) {
-        let plugin_res = self
-            .hooks()
+        let Self {
+            project,
+            hooks,
+            mut event_log,
+            ..
+        } = self;
+        let plugin_res = project
+            .get()
+            .and_then(|p| hooks.get(p))
             .map(|hooks| hooks.events().and_then(|e| e.publish.as_ref()));
         match plugin_res {
             Ok(plugin) => {
-                self.event_log.publish(plugin);
+                event_log.add_event_args();
+                event_log.publish(plugin);
             }
             Err(e) => {
                 debug!("Unable to publish event log.\n{}", e);