rust: modes module cleanup

Author: rizsotto

rust/bear/src/bin/bear.rs

@@ -1,6 +1,9 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-use bear::modes::{Combined, Intercept, Mode, Semantic};
+use bear::modes::Mode;
+use bear::modes::intercept::Intercept;
+use bear::modes::semantic::Semantic;
+use bear::modes::combined::Combined;
 use bear::{args, config};
 use std::env;
 use std::process::ExitCode;
@@ -68,12 +71,9 @@ impl Application {
             Application::Semantic(semantic) => semantic.run(),
             Application::Combined(all) => all.run(),
         };
-        match status {
-            Ok(code) => code,
-            Err(error) => {
-                log::error!("Run failed: {}", error);
-                ExitCode::FAILURE
-            }
-        }
+        status.unwrap_or_else(|error| {
+            log::error!("Bear: {}", error);
+            ExitCode::FAILURE
+        })
     }
 }

rust/bear/src/bin/wrapper.rs

@@ -21,7 +21,7 @@ use anyhow::{Context, Result};
 use bear::ipc::tcp::ReporterOnTcp;
 use bear::ipc::Reporter;
 use bear::ipc::{Event, Execution, ProcessId};
-use bear::modes::KEY_DESTINATION;
+use bear::modes::intercept::KEY_DESTINATION;
 use std::path::{Path, PathBuf};
 
 /// Implementation of the wrapper process.

rust/bear/src/ipc/mod.rs

@@ -11,6 +11,7 @@
 
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
+use std::fmt;
 use std::path::PathBuf;
 use std::sync::mpsc::Sender;
 
@@ -81,6 +82,17 @@ pub struct Execution {
     pub environment: HashMap<String, String>,
 }
 
+impl fmt::Display for Execution {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "Execution path={}, args=[{}]",
+            self.executable.display(),
+            self.arguments.join(",")
+        )
+    }
+}
+
 /// Reporter id is a unique identifier for a reporter.
 ///
 /// It is used to identify the process that sends the execution report.

rust/bear/src/modes/combined.rs

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+use crate::ipc::Envelope;
+use crate::modes::intercept::{CollectorService, InterceptEnvironment};
+use crate::modes::semantic::Recognition;
+use crate::modes::Mode;
+use crate::output::OutputWriter;
+use crate::semantic::transformation::Transformation;
+use crate::semantic::Transform;
+use crate::{args, config};
+use anyhow::Context;
+use std::process::ExitCode;
+
+/// The all model is combining the intercept and semantic modes.
+pub struct Combined {
+    command: args::BuildCommand,
+    intercept_config: config::Intercept,
+    semantic_recognition: Recognition,
+    semantic_transform: Transformation,
+    output_writer: OutputWriter,
+}
+
+impl Combined {
+    /// Create a new all mode instance.
+    pub fn from(
+        command: args::BuildCommand,
+        output: args::BuildSemantic,
+        config: config::Main,
+    ) -> anyhow::Result<Self> {
+        let semantic_recognition = Recognition::try_from(&config)?;
+        let semantic_transform = Transformation::from(&config.output);
+        let output_writer = OutputWriter::configure(&output, &config.output)?;
+        let intercept_config = config.intercept;
+
+        Ok(Self {
+            command,
+            intercept_config,
+            semantic_recognition,
+            semantic_transform,
+            output_writer,
+        })
+    }
+
+    /// Consumer the envelopes for analysis and write the result to the output file.
+    /// This implements the pipeline of the semantic analysis. Same as the `Semantic` mode.
+    fn consume_for_analysis(
+        semantic_recognition: Recognition,
+        semantic_transform: Transformation,
+        output_writer: OutputWriter,
+        envelopes: impl IntoIterator<Item = Envelope>,
+    ) -> anyhow::Result<()> {
+        let entries = envelopes
+            .into_iter()
+            .map(|envelope| envelope.event.execution)
+            .flat_map(|execution| semantic_recognition.apply(execution))
+            .flat_map(|semantic| semantic_transform.apply(semantic));
+
+        output_writer.run(entries)
+    }
+}
+
+impl Mode for Combined {
+    /// Run the all mode by setting up the collector service and the intercept environment.
+    /// The build command is executed in the intercept environment. The collected events are
+    /// then processed by the semantic recognition and transformation. The result is written
+    /// to the output file.
+    ///
+    /// The exit code is based on the result of the build command.
+    fn run(self) -> anyhow::Result<ExitCode> {
+        let semantic_recognition = self.semantic_recognition;
+        let semantic_transform = self.semantic_transform;
+        let output_writer = self.output_writer;
+        let service = CollectorService::new(move |envelopes| {
+            Self::consume_for_analysis(
+                semantic_recognition,
+                semantic_transform,
+                output_writer,
+                envelopes,
+            )
+        })
+            .with_context(|| "Failed to create the ipc service")?;
+        let environment = InterceptEnvironment::new(&self.intercept_config, service.address())
+            .with_context(|| "Failed to create the ipc environment")?;
+
+        let status = environment
+            .execute_build_command(self.command)
+            .with_context(|| "Failed to execute the build command")?;
+
+        Ok(status)
+    }
+}

rust/bear/src/modes/input.rs

@@ -1,16 +1,85 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-use super::{KEY_DESTINATION, KEY_PRELOAD_PATH};
+use super::Mode;
 use crate::ipc::tcp::CollectorOnTcp;
 use crate::ipc::{Collector, Envelope};
 use crate::{args, config};
+use anyhow::Context;
+use std::io::BufWriter;
 use std::path::{Path, PathBuf};
 use std::process::{Command, ExitCode};
 use std::sync::mpsc::channel;
 use std::sync::mpsc::Receiver;
 use std::sync::Arc;
 use std::{env, thread};
 
+/// Declare the environment variables used by the intercept mode.
+pub const KEY_DESTINATION: &str = "INTERCEPT_REPORTER_ADDRESS";
+pub const KEY_PRELOAD_PATH: &str = "LD_PRELOAD";
+
+/// The intercept mode we are only capturing the build commands
+/// and write it into the output file.
+pub struct Intercept {
+    command: args::BuildCommand,
+    output: args::BuildEvents,
+    config: config::Intercept,
+}
+
+impl Intercept {
+    /// Create a new intercept mode instance.
+    pub fn from(
+        command: args::BuildCommand,
+        output: args::BuildEvents,
+        config: config::Main,
+    ) -> anyhow::Result<Self> {
+        Ok(Self {
+            command,
+            output,
+            config: config.intercept,
+        })
+    }
+
+    /// Consume events and write them into the output file.
+    fn write_to_file(
+        output_file_name: String,
+        envelopes: impl IntoIterator<Item = Envelope>,
+    ) -> anyhow::Result<()> {
+        let mut writer = std::fs::File::create(&output_file_name)
+            .map(BufWriter::new)
+            .with_context(|| format!("Failed to create output file: {:?}", &output_file_name))?;
+        for envelope in envelopes {
+            serde_json::to_writer(&mut writer, &envelope).with_context(|| {
+                format!("Failed to write execution report: {:?}", &output_file_name)
+            })?;
+            // TODO: add a newline character to separate the entries
+        }
+        Ok(())
+    }
+}
+
+impl Mode for Intercept {
+    /// Run the intercept mode by setting up the collector service and
+    /// the intercept environment. The build command is executed in the
+    /// intercept environment.
+    ///
+    /// The exit code is based on the result of the build command.
+    fn run(self) -> anyhow::Result<ExitCode> {
+        let output_file_name = self.output.file_name.clone();
+        let service = CollectorService::new(move |envelopes| {
+            Self::write_to_file(output_file_name, envelopes)
+        })
+            .with_context(|| "Failed to create the ipc service")?;
+        let environment = InterceptEnvironment::new(&self.config, service.address())
+            .with_context(|| "Failed to create the ipc environment")?;
+
+        let status = environment
+            .execute_build_command(self.command)
+            .with_context(|| "Failed to execute the build command")?;
+
+        Ok(status)
+    }
+}
+
 /// The service is responsible for collecting the events from the supervised processes.
 ///
 /// The service is implemented as TCP server that listens on a random port on the loopback