rust: bear run all implemented

Author: rizsotto

rust/bear/src/bin/bear.rs

@@ -52,11 +52,13 @@ impl Application {
     fn configure(args: args::Arguments, config: config::Main) -> anyhow::Result<Self> {
         match args.mode {
             args::Mode::Intercept { input, output } => {
+                log::debug!("Mode: intercept");
                 let intercept_config = config.intercept;
                 let mode = Intercept::new(input, output, intercept_config);
                 Ok(Application::Intercept(mode))
             }
             args::Mode::Semantic { input, output } => {
+                log::debug!("Mode: semantic analysis");
                 let event_source = EventFileReader::try_from(input)?;
                 let semantic_recognition = Recognition::try_from(&config)?;
                 let semantic_transform = Transformation::from(&config.output);
@@ -70,9 +72,18 @@ impl Application {
                 Ok(Application::Semantic(mode))
             }
             args::Mode::All { input, output } => {
+                log::debug!("Mode: intercept and semantic analysis");
+                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;
-                let output_config = config.output;
-                let mode = All::new(input, output, intercept_config, output_config);
+                let mode = All::new(
+                    input,
+                    intercept_config,
+                    semantic_recognition,
+                    semantic_transform,
+                    output_writer,
+                );
                 Ok(Application::All(mode))
             }
         }
@@ -84,7 +95,12 @@ impl Application {
             Application::Semantic(semantic) => semantic.run(),
             Application::All(all) => all.run(),
         };
-        // TODO: log the status
-        status.unwrap_or(ExitCode::FAILURE)
+        match status {
+            Ok(code) => code,
+            Err(error) => {
+                log::error!("Run failed: {}", error);
+                ExitCode::FAILURE
+            }
+        }
     }
 }

rust/bear/src/intercept/collector.rs

@@ -2,8 +2,8 @@
 
 use std::net::{SocketAddr, TcpListener, TcpStream};
 
-use std::sync::mpsc::Sender;
 use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::mpsc::Sender;
 use std::sync::Arc;
 
 use super::Envelope;

rust/bear/src/modes/intercept.rs

@@ -3,10 +3,10 @@
 use crate::intercept::collector::{EventCollector, EventCollectorOnTcp};
 use crate::intercept::{Envelope, KEY_DESTINATION, KEY_PRELOAD_PATH};
 use crate::{args, config};
-use std::sync::mpsc::Receiver;
-use std::sync::mpsc::channel;
 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};
 

rust/bear/src/modes/mod.rs

@@ -38,10 +38,11 @@ pub struct Semantic {
 
 /// The all model is combining the intercept and semantic modes.
 pub struct All {
-    input: args::BuildCommand,
-    output: args::BuildSemantic,
+    command: args::BuildCommand,
     intercept_config: config::Intercept,
-    output_config: config::Output,
+    semantic_recognition: Recognition,
+    semantic_transform: Transformation,
+    output_writer: OutputWriter,
 }
 
 impl Intercept {
@@ -60,23 +61,22 @@ impl Intercept {
     /// Write the envelopes into the output file.
     fn write_to_file(
         output_file_name: String,
-        envelopes: impl IntoIterator<Item=Envelope>,
+        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 {
-            envelope
-                .write_into(&mut writer)
-                .with_context(|| "Failed to write the envelope")?;
+            envelope.write_into(&mut writer).with_context(|| {
+                format!("Failed to write execution report: {:?}", &output_file_name)
+            })?;
         }
         Ok(())
     }
 }
 
 impl Mode for Intercept {
     fn run(self) -> anyhow::Result<ExitCode> {
-        // TODO: log failures with the right context
         let output_file_name = self.output.file_name.clone();
         let service = InterceptService::new(move |envelopes| {
             Self::write_to_file(output_file_name, envelopes)
@@ -128,23 +128,58 @@ impl Mode for Semantic {
 
 impl All {
     pub fn new(
-        input: args::BuildCommand,
-        output: args::BuildSemantic,
+        command: args::BuildCommand,
         intercept_config: config::Intercept,
-        output_config: config::Output,
+        semantic_recognition: Recognition,
+        semantic_transform: Transformation,
+        output_writer: OutputWriter,
     ) -> Self {
         Self {
-            input,
-            output,
+            command,
             intercept_config,
-            output_config,
+            semantic_recognition,
+            semantic_transform,
+            output_writer,
         }
     }
+
+    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 All {
     fn run(self) -> anyhow::Result<ExitCode> {
-        // TODO: Implement the all mode.
-        Ok(ExitCode::FAILURE)
+        let semantic_recognition = self.semantic_recognition;
+        let semantic_transform = self.semantic_transform;
+        let output_writer = self.output_writer;
+        let service = InterceptService::new(move |envelopes| {
+            Self::consume_for_analysis(
+                semantic_recognition,
+                semantic_transform,
+                output_writer,
+                envelopes,
+            )
+        })
+        .with_context(|| "Failed to create the intercept service")?;
+        let environment = InterceptEnvironment::new(&self.intercept_config, service.address())
+            .with_context(|| "Failed to create the intercept environment")?;
+
+        let status = environment
+            .execute_build_command(self.command)
+            .with_context(|| "Failed to execute the build command")?;
+
+        Ok(status)
     }
 }

rust/bear/tests/intercept.rs

@@ -6,10 +6,10 @@ use bear::intercept::*;
 
 mod test {
     use super::*;
-    use std::sync::mpsc::channel;
     use std::collections::HashMap;
     use std::io::Cursor;
     use std::path::PathBuf;
+    use std::sync::mpsc::channel;
     use std::sync::Arc;
     use std::thread;
     use std::time::Duration;