rust: intercept types moved top level module

Author: rizsotto

rust/bear/src/events.rs

@@ -22,7 +22,7 @@ use std::path::PathBuf;
 
 use serde_json::{Deserializer, Error, Value};
 
-use intercept::ipc::Execution;
+use intercept::Execution;
 
 // Based on stream serializer from `serde_json` crate.
 //

rust/bear/src/main.rs

@@ -18,7 +18,7 @@
  */
 use crate::output::OutputWriter;
 use anyhow::Context;
-use intercept::ipc::Execution;
+use intercept::Execution;
 use log;
 use semantic;
 use std::fs::{File, OpenOptions};

rust/intercept/src/bin/intercept.rs

@@ -25,7 +25,7 @@ use anyhow::Result;
 use clap::{arg, ArgAction, command};
 use crossbeam_channel::bounded;
 
-use intercept::ipc::{Envelope, Event, ReporterId};
+use intercept::{Envelope, Event, ReporterId};
 use intercept::collector::{EventCollector, EventCollectorOnTcp};
 
 #[derive(Debug, PartialEq)]

rust/intercept/src/bin/wrapper.rs

@@ -21,8 +21,6 @@ extern crate core;
 
 use anyhow::Result;
 
-use intercept::ipc::{Envelope, Event, ReporterId};
-
 fn main() -> Result<()> {
     Ok(())
 }

rust/intercept/src/collector.rs

@@ -23,7 +23,7 @@ use crossbeam::channel::{Receiver, Sender};
 use crossbeam_channel::bounded;
 use serde::{Deserialize, Serialize};
 
-use super::ipc::Envelope;
+use super::Envelope;
 
 #[derive(Serialize, Deserialize, Debug, PartialEq)]
 pub struct SessionLocator(pub String);

rust/intercept/src/ipc.rs

@@ -16,7 +16,89 @@
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+use std::collections::HashMap;
+use std::io::{Read, Write};
+use std::path::PathBuf;
+
+use chrono::Utc;
+use serde::{Deserialize, Serialize};
 
-pub mod ipc;
 pub mod reporter;
 pub mod collector;
+
+// Reporter id is a unique identifier for a reporter.
+//
+// It is used to identify the process that sends the execution report.
+// Because the OS PID is not unique across a single build (PIDs are
+// recycled), we need to use a new unique identifier to identify the process.
+#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
+pub struct ReporterId(pub u64);
+
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+pub struct ProcessId(pub u32);
+
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+pub struct Execution {
+    pub executable: PathBuf,
+    pub arguments: Vec<String>,
+    pub working_dir: PathBuf,
+    pub environment: HashMap<String, String>,
+}
+
+// Represent a relevant life cycle event of a process.
+//
+// Currently, it's only the process life cycle events (start, signal,
+// terminate), but can be extended later with performance related
+// events like monitoring the CPU usage or the memory allocation if
+// this information is available.
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+pub enum Event {
+    Started {
+        pid: ProcessId,
+        ppid: ProcessId,
+        execution: Execution,
+    },
+    Terminated {
+        status: i64
+    },
+    Signaled {
+        signal: i32,
+    },
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+pub struct Envelope {
+    pub rid: ReporterId,
+    pub timestamp: u64,
+    pub event: Event,
+}
+
+impl Envelope {
+    pub fn new(rid: &ReporterId, event: Event) -> Self {
+        let timestamp = Utc::now().timestamp_millis() as u64;
+        Envelope { rid: rid.clone(), timestamp, event }
+    }
+
+    pub fn read_from(mut reader: impl Read) -> Result<Self, anyhow::Error> {
+        let mut length_bytes = [0; 4];
+        reader.read_exact(&mut length_bytes)?;
+        let length = u32::from_be_bytes(length_bytes) as usize;
+
+        let mut buffer = vec![0; length];
+        reader.read_exact(&mut buffer)?;
+        let envelope = serde_json::from_slice(buffer.as_ref())?;
+
+        Ok(envelope)
+    }
+
+    pub fn write_into(&self, mut writer: impl Write) -> Result<u32, anyhow::Error> {
+        let serialized_envelope = serde_json::to_string(&self)?;
+        let bytes = serialized_envelope.into_bytes();
+        let length = bytes.len() as u32;
+
+        writer.write_all(&length.to_be_bytes())?;
+        writer.write_all(&bytes)?;
+
+        Ok(length)
+    }
+}

rust/intercept/src/lib.rs

@@ -21,7 +21,7 @@ use std::net::TcpStream;
 
 use rand::random;
 
-use crate::ipc::{Envelope, Event, ReporterId};
+use super::{Envelope, Event, ReporterId};
 
 impl ReporterId {
     pub fn new() -> Self {

rust/intercept/src/reporter.rs

@@ -20,7 +20,7 @@
 mod fixtures;
 pub mod tools;
 
-use intercept::ipc::Execution;
+use intercept::Execution;
 use std::path::PathBuf;
 
 /// Represents a semantic recognition result.

rust/semantic/src/lib.rs

@@ -17,8 +17,8 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-use crate::{Meaning, RecognitionResult, Tool};
-use intercept::ipc::Execution;
+use crate::{RecognitionResult, Tool};
+use intercept::Execution;
 
 /// Represents a set of tools, where any of them can recognize the semantic.
 /// The evaluation is done in the order of the tools. The first one which
@@ -52,6 +52,7 @@ mod test {
     use std::collections::HashMap;
     use std::path::PathBuf;
 
+    use super::super::super::Meaning;
     use super::*;
 
     #[test]