rust: bear application code migrated to library

Author: rizsotto

rust/bear/src/bin/bear.rs

@@ -1,18 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 use bear::input::EventFileReader;
-use bear::intercept::collector::{EventCollector, EventCollectorOnTcp};
-use bear::intercept::{Envelope, KEY_DESTINATION, KEY_PRELOAD_PATH};
+use bear::modes::{All, Intercept, Mode, Semantic};
 use bear::output::OutputWriter;
 use bear::recognition::Recognition;
 use bear::transformation::Transformation;
 use bear::{args, config};
-use crossbeam_channel::{bounded, Receiver};
 use log;
-use std::path::{Path, PathBuf};
-use std::process::{Command, ExitCode};
-use std::sync::Arc;
-use std::{env, thread};
+use std::env;
+use std::process::ExitCode;
 
 /// Driver function of the application.
 fn main() -> anyhow::Result<ExitCode> {
@@ -48,35 +44,6 @@ enum Application {
     All(All),
 }
 
-/// The intercept mode we are only capturing the build commands.
-struct Intercept {
-    input: args::BuildCommand,
-    output: args::BuildEvents,
-    config: config::Intercept,
-}
-
-/// The semantic mode we are deduct the semantic meaning of the
-/// executed commands from the build process.
-struct Semantic {
-    event_source: EventFileReader,
-    semantic_recognition: Recognition,
-    semantic_transform: Transformation,
-    output_writer: OutputWriter,
-}
-
-/// The all model is combining the intercept and semantic modes.
-struct All {
-    input: args::BuildCommand,
-    output: args::BuildSemantic,
-    intercept_config: config::Intercept,
-    output_config: config::Output,
-}
-
-/// The mode trait is used to run the application in different modes.
-trait Mode {
-    fn run(self) -> ExitCode;
-}
-
 impl Application {
     /// Configure the application based on the command line arguments and the configuration.
     ///
@@ -87,42 +54,31 @@ impl Application {
         match args.mode {
             args::Mode::Intercept { input, output } => {
                 let intercept_config = config.intercept;
-                let mode = Intercept {
-                    input,
-                    output,
-                    config: intercept_config,
-                };
+                let mode = Intercept::new(input, output, intercept_config);
                 Ok(Application::Intercept(mode))
             }
             args::Mode::Semantic { input, output } => {
                 let event_source = EventFileReader::try_from(input)?;
                 let semantic_recognition = Recognition::try_from(&config)?;
                 let semantic_transform = Transformation::from(&config.output);
                 let output_writer = OutputWriter::configure(&output, &config.output)?;
-                let mode = Semantic {
+                let mode = Semantic::new(
                     event_source,
                     semantic_recognition,
                     semantic_transform,
                     output_writer,
-                };
+                );
                 Ok(Application::Semantic(mode))
             }
             args::Mode::All { input, output } => {
                 let intercept_config = config.intercept;
                 let output_config = config.output;
-                let mode = All {
-                    input,
-                    output,
-                    intercept_config,
-                    output_config,
-                };
+                let mode = All::new(input, output, intercept_config, output_config);
                 Ok(Application::All(mode))
             }
         }
     }
-}
 
-impl Mode for Application {
     fn run(self) -> ExitCode {
         match self {
             Application::Intercept(intercept) => intercept.run(),
@@ -131,194 +87,3 @@ impl Mode for Application {
         }
     }
 }
-
-impl Mode for Intercept {
-    fn run(self) -> ExitCode {
-        match &self.config {
-            config::Intercept::Wrapper { .. } => {
-                let service = InterceptService::new()
-                    .expect("Failed to create the intercept service");
-                let environment = InterceptEnvironment::new(&self.config, service.address())
-                    .expect("Failed to create the intercept environment");
-
-                // start writer thread
-                let writer_thread = thread::spawn(move || {
-                    let mut writer = std::fs::File::create(self.output.file_name)
-                        .expect("Failed to create the output file");
-                    for envelope in service.receiver().iter() {
-                        envelope
-                            .write_into(&mut writer)
-                            .expect("Failed to write the envelope");
-                    }
-                });
-
-                let status = environment.execute_build_command(self.input);
-
-                writer_thread
-                    .join()
-                    .expect("Failed to join the writer thread");
-
-                status.unwrap_or(ExitCode::FAILURE)
-            }
-            config::Intercept::Preload { .. } => {
-                todo!()
-            }
-        }
-    }
-}
-
-impl Mode for Semantic {
-    fn run(self) -> ExitCode {
-        // Set up the pipeline of compilation database entries.
-        let entries = self
-            .event_source
-            .generate()
-            .flat_map(|execution| self.semantic_recognition.apply(execution))
-            .flat_map(|semantic| self.semantic_transform.apply(semantic));
-        // Consume the entries and write them to the output file.
-        // The exit code is based on the result of the output writer.
-        match self.output_writer.run(entries) {
-            Ok(_) => ExitCode::SUCCESS,
-            Err(_) => ExitCode::FAILURE,
-        }
-    }
-}
-
-impl Mode for All {
-    fn run(self) -> ExitCode {
-        // TODO: Implement the all mode.
-        ExitCode::FAILURE
-    }
-}
-
-struct InterceptService {
-    collector: Arc<EventCollectorOnTcp>,
-    receiver: Receiver<Envelope>,
-    collector_thread: Option<thread::JoinHandle<()>>,
-}
-
-impl InterceptService {
-    pub fn new() -> anyhow::Result<Self> {
-        let collector = EventCollectorOnTcp::new()?;
-        let collector_arc = Arc::new(collector);
-        let (sender, receiver) = bounded(32);
-
-        let collector_in_thread = collector_arc.clone();
-        let collector_thread = thread::spawn(move || {
-            collector_in_thread.collect(sender).unwrap();
-        });
-
-        Ok(InterceptService {
-            collector: collector_arc,
-            receiver,
-            collector_thread: Some(collector_thread),
-        })
-    }
-
-    pub fn receiver(&self) -> Receiver<Envelope> {
-        self.receiver.clone()
-    }
-
-    pub fn address(&self) -> String {
-        self.collector.address()
-    }
-}
-
-impl Drop for InterceptService {
-    fn drop(&mut self) {
-        self.collector.stop().expect("Failed to stop the collector");
-        if let Some(thread) = self.collector_thread.take() {
-            thread.join().expect("Failed to join the collector thread");
-        }
-    }
-}
-
-enum InterceptEnvironment {
-    Wrapper {
-        bin_dir: tempfile::TempDir,
-        address: String,
-    },
-    Preload {
-        path: PathBuf,
-        address: String,
-    },
-}
-
-impl InterceptEnvironment {
-    pub fn new(config: &config::Intercept, address: String) -> anyhow::Result<Self> {
-        let result = match config {
-            config::Intercept::Wrapper {
-                path,
-                directory,
-                executables,
-            } => {
-                // Create a temporary directory and populate it with the executables.
-                let bin_dir = tempfile::TempDir::with_prefix_in(directory, "bear-")?;
-                for executable in executables {
-                    std::fs::hard_link(&executable, &path)?;
-                }
-                InterceptEnvironment::Wrapper { bin_dir, address }
-            }
-            config::Intercept::Preload { path } => InterceptEnvironment::Preload {
-                path: path.clone(),
-                address,
-            },
-        };
-        Ok(result)
-    }
-
-    pub fn execute_build_command(self, input: args::BuildCommand) -> anyhow::Result<ExitCode> {
-        let environment = self.environment();
-        let mut child = Command::new(input.arguments[0].clone())
-            .args(input.arguments)
-            .envs(environment)
-            .spawn()?;
-
-        let result = child.wait()?;
-
-        if result.success() {
-            Ok(ExitCode::SUCCESS)
-        } else {
-            result
-                .code()
-                .map_or(Ok(ExitCode::FAILURE), |code| Ok(ExitCode::from(code as u8)))
-        }
-    }
-
-    fn environment(&self) -> Vec<(String, String)> {
-        match self {
-            InterceptEnvironment::Wrapper {
-                bin_dir, address, ..
-            } => {
-                let path_original = env::var("PATH").unwrap_or_else(|_| String::new());
-                let path_updated = InterceptEnvironment::insert_to_path(
-                    &path_original,
-                    Self::to_string(bin_dir.path()),
-                );
-                vec![
-                    ("PATH".to_string(), path_updated),
-                    (KEY_DESTINATION.to_string(), address.clone()),
-                ]
-            }
-            InterceptEnvironment::Preload { path, address, .. } => {
-                let path_original = env::var(KEY_PRELOAD_PATH).unwrap_or_else(|_| String::new());
-                let path_updated =
-                    InterceptEnvironment::insert_to_path(&path_original, Self::to_string(path));
-                vec![
-                    (KEY_PRELOAD_PATH.to_string(), path_updated),
-                    (KEY_DESTINATION.to_string(), address.clone()),
-                ]
-            }
-        }
-    }
-
-    fn insert_to_path(original: &str, first: String) -> String {
-        let mut paths: Vec<_> = original.split(':').filter(|it| it != &first).collect();
-        paths.insert(0, first.as_str());
-        paths.join(":")
-    }
-
-    fn to_string(path: &Path) -> String {
-        path.to_str().unwrap_or("").to_string()
-    }
-}

rust/bear/src/lib.rs

@@ -5,6 +5,7 @@ pub mod config;
 mod fixtures;
 pub mod input;
 pub mod intercept;
+pub mod modes;
 pub mod output;
 pub mod recognition;
 pub mod semantic;