rust: event serializers are in the same module as the declarations

Author: rizsotto

rust/bear/src/intercept/mod.rs

@@ -11,12 +11,14 @@
 
 use crate::{args, config};
 use serde::{Deserialize, Serialize};
+use serde_json::de::IoRead;
+use serde_json::StreamDeserializer;
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::process::{Command, ExitCode};
 use std::sync::mpsc::{channel, Receiver, Sender};
 use std::sync::Arc;
-use std::{env, fmt, thread};
+use std::{env, fmt, io, thread};
 
 pub mod tcp;
 
@@ -331,3 +333,143 @@ impl InterceptEnvironment {
         path.to_str().unwrap_or("").to_string()
     }
 }
+
+/// Generate the build events from the file.
+///
+/// Returns an iterator over the build events.
+/// Any error will interrupt the reading process and the remaining events will be lost.
+pub fn read(reader: impl io::Read) -> impl Iterator<Item = Envelope> {
+    let stream = StreamDeserializer::new(IoRead::new(reader));
+    stream.filter_map(|result| match result {
+        Ok(value) => Some(value),
+        Err(error) => {
+            log::error!("Failed to read event: {:?}", error);
+            None
+        }
+    })
+}
+
+/// Write the build events to the file.
+///
+/// Can fail if the events cannot be serialized or written to the file.
+/// Any error will interrupt the writing process and the file will be incomplete.
+pub fn write(
+    mut writer: impl io::Write,
+    envelopes: impl IntoIterator<Item = Envelope>,
+) -> Result<(), anyhow::Error> {
+    for envelope in envelopes {
+        serde_json::to_writer(&mut writer, &envelope)?;
+        writer.write_all(b"\n")?;
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::vec_of_strings;
+    use serde_json::json;
+    use std::collections::HashMap;
+    use std::path::PathBuf;
+
+    #[test]
+    fn read_write() {
+        let events = expected_values();
+
+        let mut buffer = Vec::new();
+        write(&mut buffer, events.iter().cloned()).unwrap();
+        let mut cursor = io::Cursor::new(buffer);
+        let read_events: Vec<_> = read(&mut cursor).collect();
+
+        assert_eq!(events, read_events);
+    }
+
+    #[test]
+    fn read_write_empty() {
+        let events = Vec::<Envelope>::new();
+
+        let mut buffer = Vec::new();
+        write(&mut buffer, events.iter().cloned()).unwrap();
+        let mut cursor = io::Cursor::new(buffer);
+        let read_events: Vec<_> = read(&mut cursor).collect();
+
+        assert_eq!(events, read_events);
+    }
+
+    #[test]
+    fn read_stops_on_errors() {
+        let line1 = json!({
+            "rid": 42,
+            "timestamp": 0,
+            "event": {
+                "pid": 11782,
+                "execution": {
+                    "executable": "/usr/bin/clang",
+                    "arguments": ["clang", "-c", "main.c"],
+                    "working_dir": "/home/user",
+                    "environment": {
+                        "PATH": "/usr/bin",
+                        "HOME": "/home/user"
+                    }
+                }
+            }
+        });
+        let line2 = json!({"rid": 42 });
+        let line3 = json!({
+            "rid": 42,
+            "timestamp": 273,
+            "event": {
+                "pid": 11934,
+                "execution": {
+                    "executable": "/usr/bin/clang",
+                    "arguments": ["clang", "-c", "output.c"],
+                    "working_dir": "/home/user",
+                    "environment": {}
+                }
+            }
+        });
+        let content = format!("{}\n{}\n{}\n", line1, line2, line3);
+
+        let mut cursor = io::Cursor::new(content);
+        let read_events: Vec<_> = read(&mut cursor).collect();
+
+        // Only the fist event is read, all other lines are ignored.
+        assert_eq!(expected_values()[0..1], read_events);
+    }
+
+    const REPORTER_ID: ReporterId = ReporterId(42);
+
+    fn expected_values() -> Vec<Envelope> {
+        vec![
+            Envelope {
+                rid: REPORTER_ID,
+                timestamp: 0,
+                event: Event {
+                    pid: ProcessId(11782),
+                    execution: Execution {
+                        executable: PathBuf::from("/usr/bin/clang"),
+                        arguments: vec_of_strings!["clang", "-c", "main.c"],
+                        working_dir: PathBuf::from("/home/user"),
+                        environment: HashMap::from([
+                            ("PATH".to_string(), "/usr/bin".to_string()),
+                            ("HOME".to_string(), "/home/user".to_string()),
+                        ]),
+                    },
+                },
+            },
+            Envelope {
+                rid: REPORTER_ID,
+                timestamp: 273,
+                event: Event {
+                    pid: ProcessId(11934),
+                    execution: Execution {
+                        executable: PathBuf::from("/usr/bin/clang"),
+                        arguments: vec_of_strings!["clang", "-c", "output.c"],
+                        working_dir: PathBuf::from("/home/user"),
+                        environment: HashMap::from([]),
+                    },
+                },
+            },
+        ]
+    }
+}

rust/bear/src/modes/mod.rs

@@ -3,9 +3,9 @@
 pub mod intercept;
 pub mod semantic;
 
+use crate::intercept::{read, write};
 use crate::modes::intercept::BuildInterceptor;
 use crate::modes::semantic::SemanticAnalysisPipeline;
-use crate::output::event::{read, write};
 use crate::{args, config};
 use anyhow::Context;
 use std::fs::{File, OpenOptions};

rust/bear/src/output/event/mod.rs

@@ -9,7 +9,6 @@ use anyhow::{anyhow, Context, Result};
 use path_absolutize::Absolutize;
 
 mod clang;
-pub mod event;
 mod filter;
 
 /// The output writer trait is responsible for writing output file.